mirror of
https://github.com/opencv/opencv.git
synced 2024-12-11 22:59:16 +08:00
5850 lines
219 KiB
C
5850 lines
219 KiB
C
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
||
|
// source: opencv-onnx.proto
|
||
|
|
||
|
#ifndef PROTOBUF_opencv_2donnx_2eproto__INCLUDED
|
||
|
#define PROTOBUF_opencv_2donnx_2eproto__INCLUDED
|
||
|
|
||
|
#include <string>
|
||
|
|
||
|
#include <google/protobuf/stubs/common.h>
|
||
|
|
||
|
#if GOOGLE_PROTOBUF_VERSION < 3005000
|
||
|
#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 3005001 < GOOGLE_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/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.h>
|
||
|
#include <google/protobuf/message.h>
|
||
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
||
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
||
|
#include <google/protobuf/generated_enum_reflection.h>
|
||
|
#include <google/protobuf/unknown_field_set.h>
|
||
|
// @@protoc_insertion_point(includes)
|
||
|
|
||
|
namespace protobuf_opencv_2donnx_2eproto {
|
||
|
// Internal implementation detail -- do not use these members.
|
||
|
struct TableStruct {
|
||
|
static const ::google::protobuf::internal::ParseTableField entries[];
|
||
|
static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
|
||
|
static const ::google::protobuf::internal::ParseTable schema[13];
|
||
|
static const ::google::protobuf::internal::FieldMetadata field_metadata[];
|
||
|
static const ::google::protobuf::internal::SerializationTable serialization_table[];
|
||
|
static const ::google::protobuf::uint32 offsets[];
|
||
|
};
|
||
|
void AddDescriptors();
|
||
|
void InitDefaultsAttributeProtoImpl();
|
||
|
void InitDefaultsAttributeProto();
|
||
|
void InitDefaultsValueInfoProtoImpl();
|
||
|
void InitDefaultsValueInfoProto();
|
||
|
void InitDefaultsModelProtoImpl();
|
||
|
void InitDefaultsModelProto();
|
||
|
void InitDefaultsStringStringEntryProtoImpl();
|
||
|
void InitDefaultsStringStringEntryProto();
|
||
|
void InitDefaultsTensorProto_SegmentImpl();
|
||
|
void InitDefaultsTensorProto_Segment();
|
||
|
void InitDefaultsTensorProtoImpl();
|
||
|
void InitDefaultsTensorProto();
|
||
|
void InitDefaultsTensorShapeProto_DimensionImpl();
|
||
|
void InitDefaultsTensorShapeProto_Dimension();
|
||
|
void InitDefaultsTensorShapeProtoImpl();
|
||
|
void InitDefaultsTensorShapeProto();
|
||
|
void InitDefaultsTypeProto_TensorImpl();
|
||
|
void InitDefaultsTypeProto_Tensor();
|
||
|
void InitDefaultsTypeProtoImpl();
|
||
|
void InitDefaultsTypeProto();
|
||
|
void InitDefaultsOperatorSetIdProtoImpl();
|
||
|
void InitDefaultsOperatorSetIdProto();
|
||
|
inline void InitDefaults() {
|
||
|
InitDefaultsAttributeProto();
|
||
|
InitDefaultsValueInfoProto();
|
||
|
InitDefaultsModelProto();
|
||
|
InitDefaultsStringStringEntryProto();
|
||
|
InitDefaultsTensorProto_Segment();
|
||
|
InitDefaultsTensorProto();
|
||
|
InitDefaultsTensorShapeProto_Dimension();
|
||
|
InitDefaultsTensorShapeProto();
|
||
|
InitDefaultsTypeProto_Tensor();
|
||
|
InitDefaultsTypeProto();
|
||
|
InitDefaultsOperatorSetIdProto();
|
||
|
}
|
||
|
} // namespace protobuf_opencv_2donnx_2eproto
|
||
|
namespace opencv_onnx {
|
||
|
class AttributeProto;
|
||
|
class AttributeProtoDefaultTypeInternal;
|
||
|
extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_;
|
||
|
class GraphProto;
|
||
|
class GraphProtoDefaultTypeInternal;
|
||
|
extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_;
|
||
|
class ModelProto;
|
||
|
class ModelProtoDefaultTypeInternal;
|
||
|
extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
|
||
|
class NodeProto;
|
||
|
class NodeProtoDefaultTypeInternal;
|
||
|
extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_;
|
||
|
class OperatorSetIdProto;
|
||
|
class OperatorSetIdProtoDefaultTypeInternal;
|
||
|
extern OperatorSetIdProtoDefaultTypeInternal _OperatorSetIdProto_default_instance_;
|
||
|
class StringStringEntryProto;
|
||
|
class StringStringEntryProtoDefaultTypeInternal;
|
||
|
extern StringStringEntryProtoDefaultTypeInternal _StringStringEntryProto_default_instance_;
|
||
|
class TensorProto;
|
||
|
class TensorProtoDefaultTypeInternal;
|
||
|
extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_;
|
||
|
class TensorProto_Segment;
|
||
|
class TensorProto_SegmentDefaultTypeInternal;
|
||
|
extern TensorProto_SegmentDefaultTypeInternal _TensorProto_Segment_default_instance_;
|
||
|
class TensorShapeProto;
|
||
|
class TensorShapeProtoDefaultTypeInternal;
|
||
|
extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_;
|
||
|
class TensorShapeProto_Dimension;
|
||
|
class TensorShapeProto_DimensionDefaultTypeInternal;
|
||
|
extern TensorShapeProto_DimensionDefaultTypeInternal _TensorShapeProto_Dimension_default_instance_;
|
||
|
class TypeProto;
|
||
|
class TypeProtoDefaultTypeInternal;
|
||
|
extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_;
|
||
|
class TypeProto_Tensor;
|
||
|
class TypeProto_TensorDefaultTypeInternal;
|
||
|
extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_;
|
||
|
class ValueInfoProto;
|
||
|
class ValueInfoProtoDefaultTypeInternal;
|
||
|
extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_;
|
||
|
} // namespace opencv_onnx
|
||
|
namespace opencv_onnx {
|
||
|
|
||
|
enum AttributeProto_AttributeType {
|
||
|
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_FLOATS = 6,
|
||
|
AttributeProto_AttributeType_INTS = 7,
|
||
|
AttributeProto_AttributeType_STRINGS = 8,
|
||
|
AttributeProto_AttributeType_TENSORS = 9,
|
||
|
AttributeProto_AttributeType_GRAPHS = 10
|
||
|
};
|
||
|
bool AttributeProto_AttributeType_IsValid(int value);
|
||
|
const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MIN = AttributeProto_AttributeType_UNDEFINED;
|
||
|
const AttributeProto_AttributeType AttributeProto_AttributeType_AttributeType_MAX = AttributeProto_AttributeType_GRAPHS;
|
||
|
const int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = AttributeProto_AttributeType_AttributeType_MAX + 1;
|
||
|
|
||
|
const ::google::protobuf::EnumDescriptor* AttributeProto_AttributeType_descriptor();
|
||
|
inline const ::std::string& AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) {
|
||
|
return ::google::protobuf::internal::NameOfEnum(
|
||
|
AttributeProto_AttributeType_descriptor(), value);
|
||
|
}
|
||
|
inline bool AttributeProto_AttributeType_Parse(
|
||
|
const ::std::string& name, AttributeProto_AttributeType* value) {
|
||
|
return ::google::protobuf::internal::ParseNamedEnum<AttributeProto_AttributeType>(
|
||
|
AttributeProto_AttributeType_descriptor(), name, value);
|
||
|
}
|
||
|
enum TensorProto_DataType {
|
||
|
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
|
||
|
};
|
||
|
bool TensorProto_DataType_IsValid(int value);
|
||
|
const TensorProto_DataType TensorProto_DataType_DataType_MIN = TensorProto_DataType_UNDEFINED;
|
||
|
const TensorProto_DataType TensorProto_DataType_DataType_MAX = TensorProto_DataType_COMPLEX128;
|
||
|
const int TensorProto_DataType_DataType_ARRAYSIZE = TensorProto_DataType_DataType_MAX + 1;
|
||
|
|
||
|
const ::google::protobuf::EnumDescriptor* TensorProto_DataType_descriptor();
|
||
|
inline const ::std::string& TensorProto_DataType_Name(TensorProto_DataType value) {
|
||
|
return ::google::protobuf::internal::NameOfEnum(
|
||
|
TensorProto_DataType_descriptor(), value);
|
||
|
}
|
||
|
inline bool TensorProto_DataType_Parse(
|
||
|
const ::std::string& name, TensorProto_DataType* value) {
|
||
|
return ::google::protobuf::internal::ParseNamedEnum<TensorProto_DataType>(
|
||
|
TensorProto_DataType_descriptor(), name, value);
|
||
|
}
|
||
|
enum Version {
|
||
|
_START_VERSION = 0,
|
||
|
IR_VERSION_2017_10_10 = 1,
|
||
|
IR_VERSION_2017_10_30 = 2,
|
||
|
IR_VERSION = 3
|
||
|
};
|
||
|
bool Version_IsValid(int value);
|
||
|
const Version Version_MIN = _START_VERSION;
|
||
|
const Version Version_MAX = IR_VERSION;
|
||
|
const int Version_ARRAYSIZE = Version_MAX + 1;
|
||
|
|
||
|
const ::google::protobuf::EnumDescriptor* Version_descriptor();
|
||
|
inline const ::std::string& Version_Name(Version value) {
|
||
|
return ::google::protobuf::internal::NameOfEnum(
|
||
|
Version_descriptor(), value);
|
||
|
}
|
||
|
inline bool Version_Parse(
|
||
|
const ::std::string& name, Version* value) {
|
||
|
return ::google::protobuf::internal::ParseNamedEnum<Version>(
|
||
|
Version_descriptor(), name, value);
|
||
|
}
|
||
|
// ===================================================================
|
||
|
|
||
|
class AttributeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.AttributeProto) */ {
|
||
|
public:
|
||
|
AttributeProto();
|
||
|
virtual ~AttributeProto();
|
||
|
|
||
|
AttributeProto(const AttributeProto& from);
|
||
|
|
||
|
inline AttributeProto& operator=(const AttributeProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
AttributeProto(AttributeProto&& from) noexcept
|
||
|
: AttributeProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline AttributeProto& operator=(AttributeProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const AttributeProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const AttributeProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const AttributeProto*>(
|
||
|
&_AttributeProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
0;
|
||
|
|
||
|
void Swap(AttributeProto* other);
|
||
|
friend void swap(AttributeProto& a, AttributeProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline AttributeProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
AttributeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const AttributeProto& from);
|
||
|
void MergeFrom(const AttributeProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(AttributeProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
typedef AttributeProto_AttributeType AttributeType;
|
||
|
static const AttributeType UNDEFINED =
|
||
|
AttributeProto_AttributeType_UNDEFINED;
|
||
|
static const AttributeType FLOAT =
|
||
|
AttributeProto_AttributeType_FLOAT;
|
||
|
static const AttributeType INT =
|
||
|
AttributeProto_AttributeType_INT;
|
||
|
static const AttributeType STRING =
|
||
|
AttributeProto_AttributeType_STRING;
|
||
|
static const AttributeType TENSOR =
|
||
|
AttributeProto_AttributeType_TENSOR;
|
||
|
static const AttributeType GRAPH =
|
||
|
AttributeProto_AttributeType_GRAPH;
|
||
|
static const AttributeType FLOATS =
|
||
|
AttributeProto_AttributeType_FLOATS;
|
||
|
static const AttributeType INTS =
|
||
|
AttributeProto_AttributeType_INTS;
|
||
|
static const AttributeType STRINGS =
|
||
|
AttributeProto_AttributeType_STRINGS;
|
||
|
static const AttributeType TENSORS =
|
||
|
AttributeProto_AttributeType_TENSORS;
|
||
|
static const AttributeType GRAPHS =
|
||
|
AttributeProto_AttributeType_GRAPHS;
|
||
|
static inline bool AttributeType_IsValid(int value) {
|
||
|
return AttributeProto_AttributeType_IsValid(value);
|
||
|
}
|
||
|
static const AttributeType AttributeType_MIN =
|
||
|
AttributeProto_AttributeType_AttributeType_MIN;
|
||
|
static const AttributeType AttributeType_MAX =
|
||
|
AttributeProto_AttributeType_AttributeType_MAX;
|
||
|
static const int AttributeType_ARRAYSIZE =
|
||
|
AttributeProto_AttributeType_AttributeType_ARRAYSIZE;
|
||
|
static inline const ::google::protobuf::EnumDescriptor*
|
||
|
AttributeType_descriptor() {
|
||
|
return AttributeProto_AttributeType_descriptor();
|
||
|
}
|
||
|
static inline const ::std::string& AttributeType_Name(AttributeType value) {
|
||
|
return AttributeProto_AttributeType_Name(value);
|
||
|
}
|
||
|
static inline bool AttributeType_Parse(const ::std::string& name,
|
||
|
AttributeType* value) {
|
||
|
return AttributeProto_AttributeType_Parse(name, value);
|
||
|
}
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated float floats = 7;
|
||
|
int floats_size() const;
|
||
|
void clear_floats();
|
||
|
static const int kFloatsFieldNumber = 7;
|
||
|
float floats(int index) const;
|
||
|
void set_floats(int index, float value);
|
||
|
void add_floats(float value);
|
||
|
const ::google::protobuf::RepeatedField< float >&
|
||
|
floats() const;
|
||
|
::google::protobuf::RepeatedField< float >*
|
||
|
mutable_floats();
|
||
|
|
||
|
// repeated int64 ints = 8;
|
||
|
int ints_size() const;
|
||
|
void clear_ints();
|
||
|
static const int kIntsFieldNumber = 8;
|
||
|
::google::protobuf::int64 ints(int index) const;
|
||
|
void set_ints(int index, ::google::protobuf::int64 value);
|
||
|
void add_ints(::google::protobuf::int64 value);
|
||
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
ints() const;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
mutable_ints();
|
||
|
|
||
|
// repeated bytes strings = 9;
|
||
|
int strings_size() const;
|
||
|
void clear_strings();
|
||
|
static const int kStringsFieldNumber = 9;
|
||
|
const ::std::string& strings(int index) const;
|
||
|
::std::string* mutable_strings(int index);
|
||
|
void set_strings(int index, const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_strings(int index, ::std::string&& value);
|
||
|
#endif
|
||
|
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);
|
||
|
#if LANG_CXX11
|
||
|
void add_strings(::std::string&& value);
|
||
|
#endif
|
||
|
void add_strings(const char* value);
|
||
|
void add_strings(const void* value, size_t size);
|
||
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& strings() const;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_strings();
|
||
|
|
||
|
// repeated .opencv_onnx.TensorProto tensors = 10;
|
||
|
int tensors_size() const;
|
||
|
void clear_tensors();
|
||
|
static const int kTensorsFieldNumber = 10;
|
||
|
const ::opencv_onnx::TensorProto& tensors(int index) const;
|
||
|
::opencv_onnx::TensorProto* mutable_tensors(int index);
|
||
|
::opencv_onnx::TensorProto* add_tensors();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
|
||
|
mutable_tensors();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
|
||
|
tensors() const;
|
||
|
|
||
|
// repeated .opencv_onnx.GraphProto graphs = 11;
|
||
|
int graphs_size() const;
|
||
|
void clear_graphs();
|
||
|
static const int kGraphsFieldNumber = 11;
|
||
|
const ::opencv_onnx::GraphProto& graphs(int index) const;
|
||
|
::opencv_onnx::GraphProto* mutable_graphs(int index);
|
||
|
::opencv_onnx::GraphProto* add_graphs();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >*
|
||
|
mutable_graphs();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >&
|
||
|
graphs() const;
|
||
|
|
||
|
// optional string name = 1;
|
||
|
bool has_name() const;
|
||
|
void clear_name();
|
||
|
static const int kNameFieldNumber = 1;
|
||
|
const ::std::string& name() const;
|
||
|
void set_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_name(const char* value);
|
||
|
void set_name(const char* value, size_t size);
|
||
|
::std::string* mutable_name();
|
||
|
::std::string* release_name();
|
||
|
void set_allocated_name(::std::string* name);
|
||
|
|
||
|
// optional bytes s = 4;
|
||
|
bool has_s() const;
|
||
|
void clear_s();
|
||
|
static const int kSFieldNumber = 4;
|
||
|
const ::std::string& s() const;
|
||
|
void set_s(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_s(::std::string&& value);
|
||
|
#endif
|
||
|
void set_s(const char* value);
|
||
|
void set_s(const void* value, size_t size);
|
||
|
::std::string* mutable_s();
|
||
|
::std::string* release_s();
|
||
|
void set_allocated_s(::std::string* s);
|
||
|
|
||
|
// optional string doc_string = 13;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 13;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// optional string ref_attr_name = 21;
|
||
|
bool has_ref_attr_name() const;
|
||
|
void clear_ref_attr_name();
|
||
|
static const int kRefAttrNameFieldNumber = 21;
|
||
|
const ::std::string& ref_attr_name() const;
|
||
|
void set_ref_attr_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_ref_attr_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_ref_attr_name(const char* value);
|
||
|
void set_ref_attr_name(const char* value, size_t size);
|
||
|
::std::string* mutable_ref_attr_name();
|
||
|
::std::string* release_ref_attr_name();
|
||
|
void set_allocated_ref_attr_name(::std::string* ref_attr_name);
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto t = 5;
|
||
|
bool has_t() const;
|
||
|
void clear_t();
|
||
|
static const int kTFieldNumber = 5;
|
||
|
const ::opencv_onnx::TensorProto& t() const;
|
||
|
::opencv_onnx::TensorProto* release_t();
|
||
|
::opencv_onnx::TensorProto* mutable_t();
|
||
|
void set_allocated_t(::opencv_onnx::TensorProto* t);
|
||
|
|
||
|
// optional .opencv_onnx.GraphProto g = 6;
|
||
|
bool has_g() const;
|
||
|
void clear_g();
|
||
|
static const int kGFieldNumber = 6;
|
||
|
const ::opencv_onnx::GraphProto& g() const;
|
||
|
::opencv_onnx::GraphProto* release_g();
|
||
|
::opencv_onnx::GraphProto* mutable_g();
|
||
|
void set_allocated_g(::opencv_onnx::GraphProto* g);
|
||
|
|
||
|
// optional int64 i = 3;
|
||
|
bool has_i() const;
|
||
|
void clear_i();
|
||
|
static const int kIFieldNumber = 3;
|
||
|
::google::protobuf::int64 i() const;
|
||
|
void set_i(::google::protobuf::int64 value);
|
||
|
|
||
|
// optional float f = 2;
|
||
|
bool has_f() const;
|
||
|
void clear_f();
|
||
|
static const int kFFieldNumber = 2;
|
||
|
float f() const;
|
||
|
void set_f(float value);
|
||
|
|
||
|
// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
|
||
|
bool has_type() const;
|
||
|
void clear_type();
|
||
|
static const int kTypeFieldNumber = 20;
|
||
|
::opencv_onnx::AttributeProto_AttributeType type() const;
|
||
|
void set_type(::opencv_onnx::AttributeProto_AttributeType value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.AttributeProto)
|
||
|
private:
|
||
|
void set_has_name();
|
||
|
void clear_has_name();
|
||
|
void set_has_ref_attr_name();
|
||
|
void clear_has_ref_attr_name();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
void set_has_type();
|
||
|
void clear_has_type();
|
||
|
void set_has_f();
|
||
|
void clear_has_f();
|
||
|
void set_has_i();
|
||
|
void clear_has_i();
|
||
|
void set_has_s();
|
||
|
void clear_has_s();
|
||
|
void set_has_t();
|
||
|
void clear_has_t();
|
||
|
void set_has_g();
|
||
|
void clear_has_g();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedField< float > floats_;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 > ints_;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string> strings_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto > tensors_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto > graphs_;
|
||
|
::google::protobuf::internal::ArenaStringPtr name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr s_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
::google::protobuf::internal::ArenaStringPtr ref_attr_name_;
|
||
|
::opencv_onnx::TensorProto* t_;
|
||
|
::opencv_onnx::GraphProto* g_;
|
||
|
::google::protobuf::int64 i_;
|
||
|
float f_;
|
||
|
int type_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class ValueInfoProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ValueInfoProto) */ {
|
||
|
public:
|
||
|
ValueInfoProto();
|
||
|
virtual ~ValueInfoProto();
|
||
|
|
||
|
ValueInfoProto(const ValueInfoProto& from);
|
||
|
|
||
|
inline ValueInfoProto& operator=(const ValueInfoProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
ValueInfoProto(ValueInfoProto&& from) noexcept
|
||
|
: ValueInfoProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline ValueInfoProto& operator=(ValueInfoProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const ValueInfoProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const ValueInfoProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const ValueInfoProto*>(
|
||
|
&_ValueInfoProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
1;
|
||
|
|
||
|
void Swap(ValueInfoProto* other);
|
||
|
friend void swap(ValueInfoProto& a, ValueInfoProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline ValueInfoProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
ValueInfoProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ValueInfoProto& from);
|
||
|
void MergeFrom(const ValueInfoProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(ValueInfoProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional string name = 1;
|
||
|
bool has_name() const;
|
||
|
void clear_name();
|
||
|
static const int kNameFieldNumber = 1;
|
||
|
const ::std::string& name() const;
|
||
|
void set_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_name(const char* value);
|
||
|
void set_name(const char* value, size_t size);
|
||
|
::std::string* mutable_name();
|
||
|
::std::string* release_name();
|
||
|
void set_allocated_name(::std::string* name);
|
||
|
|
||
|
// optional string doc_string = 3;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 3;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// optional .opencv_onnx.TypeProto type = 2;
|
||
|
bool has_type() const;
|
||
|
void clear_type();
|
||
|
static const int kTypeFieldNumber = 2;
|
||
|
const ::opencv_onnx::TypeProto& type() const;
|
||
|
::opencv_onnx::TypeProto* release_type();
|
||
|
::opencv_onnx::TypeProto* mutable_type();
|
||
|
void set_allocated_type(::opencv_onnx::TypeProto* type);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.ValueInfoProto)
|
||
|
private:
|
||
|
void set_has_name();
|
||
|
void clear_has_name();
|
||
|
void set_has_type();
|
||
|
void clear_has_type();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
::opencv_onnx::TypeProto* type_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsValueInfoProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class NodeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.NodeProto) */ {
|
||
|
public:
|
||
|
NodeProto();
|
||
|
virtual ~NodeProto();
|
||
|
|
||
|
NodeProto(const NodeProto& from);
|
||
|
|
||
|
inline NodeProto& operator=(const NodeProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
NodeProto(NodeProto&& from) noexcept
|
||
|
: NodeProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline NodeProto& operator=(NodeProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const NodeProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const NodeProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const NodeProto*>(
|
||
|
&_NodeProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
2;
|
||
|
|
||
|
void Swap(NodeProto* other);
|
||
|
friend void swap(NodeProto& a, NodeProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline NodeProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
NodeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const NodeProto& from);
|
||
|
void MergeFrom(const NodeProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(NodeProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated string input = 1;
|
||
|
int input_size() const;
|
||
|
void clear_input();
|
||
|
static const int kInputFieldNumber = 1;
|
||
|
const ::std::string& input(int index) const;
|
||
|
::std::string* mutable_input(int index);
|
||
|
void set_input(int index, const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_input(int index, ::std::string&& value);
|
||
|
#endif
|
||
|
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);
|
||
|
#if LANG_CXX11
|
||
|
void add_input(::std::string&& value);
|
||
|
#endif
|
||
|
void add_input(const char* value);
|
||
|
void add_input(const char* value, size_t size);
|
||
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();
|
||
|
|
||
|
// repeated string output = 2;
|
||
|
int output_size() const;
|
||
|
void clear_output();
|
||
|
static const int kOutputFieldNumber = 2;
|
||
|
const ::std::string& output(int index) const;
|
||
|
::std::string* mutable_output(int index);
|
||
|
void set_output(int index, const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_output(int index, ::std::string&& value);
|
||
|
#endif
|
||
|
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);
|
||
|
#if LANG_CXX11
|
||
|
void add_output(::std::string&& value);
|
||
|
#endif
|
||
|
void add_output(const char* value);
|
||
|
void add_output(const char* value, size_t size);
|
||
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& output() const;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_output();
|
||
|
|
||
|
// repeated .opencv_onnx.AttributeProto attribute = 5;
|
||
|
int attribute_size() const;
|
||
|
void clear_attribute();
|
||
|
static const int kAttributeFieldNumber = 5;
|
||
|
const ::opencv_onnx::AttributeProto& attribute(int index) const;
|
||
|
::opencv_onnx::AttributeProto* mutable_attribute(int index);
|
||
|
::opencv_onnx::AttributeProto* add_attribute();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
|
||
|
mutable_attribute();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >&
|
||
|
attribute() const;
|
||
|
|
||
|
// optional string name = 3;
|
||
|
bool has_name() const;
|
||
|
void clear_name();
|
||
|
static const int kNameFieldNumber = 3;
|
||
|
const ::std::string& name() const;
|
||
|
void set_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_name(const char* value);
|
||
|
void set_name(const char* value, size_t size);
|
||
|
::std::string* mutable_name();
|
||
|
::std::string* release_name();
|
||
|
void set_allocated_name(::std::string* name);
|
||
|
|
||
|
// optional string op_type = 4;
|
||
|
bool has_op_type() const;
|
||
|
void clear_op_type();
|
||
|
static const int kOpTypeFieldNumber = 4;
|
||
|
const ::std::string& op_type() const;
|
||
|
void set_op_type(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_op_type(::std::string&& value);
|
||
|
#endif
|
||
|
void set_op_type(const char* value);
|
||
|
void set_op_type(const char* value, size_t size);
|
||
|
::std::string* mutable_op_type();
|
||
|
::std::string* release_op_type();
|
||
|
void set_allocated_op_type(::std::string* op_type);
|
||
|
|
||
|
// optional string doc_string = 6;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 6;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// optional string domain = 7;
|
||
|
bool has_domain() const;
|
||
|
void clear_domain();
|
||
|
static const int kDomainFieldNumber = 7;
|
||
|
const ::std::string& domain() const;
|
||
|
void set_domain(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_domain(::std::string&& value);
|
||
|
#endif
|
||
|
void set_domain(const char* value);
|
||
|
void set_domain(const char* value, size_t size);
|
||
|
::std::string* mutable_domain();
|
||
|
::std::string* release_domain();
|
||
|
void set_allocated_domain(::std::string* domain);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.NodeProto)
|
||
|
private:
|
||
|
void set_has_name();
|
||
|
void clear_has_name();
|
||
|
void set_has_op_type();
|
||
|
void clear_has_op_type();
|
||
|
void set_has_domain();
|
||
|
void clear_has_domain();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string> input_;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string> output_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto > attribute_;
|
||
|
::google::protobuf::internal::ArenaStringPtr name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr op_type_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
::google::protobuf::internal::ArenaStringPtr domain_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class ModelProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.ModelProto) */ {
|
||
|
public:
|
||
|
ModelProto();
|
||
|
virtual ~ModelProto();
|
||
|
|
||
|
ModelProto(const ModelProto& from);
|
||
|
|
||
|
inline ModelProto& operator=(const ModelProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
ModelProto(ModelProto&& from) noexcept
|
||
|
: ModelProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline ModelProto& operator=(ModelProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const ModelProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const ModelProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const ModelProto*>(
|
||
|
&_ModelProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
3;
|
||
|
|
||
|
void Swap(ModelProto* other);
|
||
|
friend void swap(ModelProto& a, ModelProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline ModelProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
ModelProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ModelProto& from);
|
||
|
void MergeFrom(const ModelProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(ModelProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
|
||
|
int opset_import_size() const;
|
||
|
void clear_opset_import();
|
||
|
static const int kOpsetImportFieldNumber = 8;
|
||
|
const ::opencv_onnx::OperatorSetIdProto& opset_import(int index) const;
|
||
|
::opencv_onnx::OperatorSetIdProto* mutable_opset_import(int index);
|
||
|
::opencv_onnx::OperatorSetIdProto* add_opset_import();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
|
||
|
mutable_opset_import();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >&
|
||
|
opset_import() const;
|
||
|
|
||
|
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
|
||
|
int metadata_props_size() const;
|
||
|
void clear_metadata_props();
|
||
|
static const int kMetadataPropsFieldNumber = 14;
|
||
|
const ::opencv_onnx::StringStringEntryProto& metadata_props(int index) const;
|
||
|
::opencv_onnx::StringStringEntryProto* mutable_metadata_props(int index);
|
||
|
::opencv_onnx::StringStringEntryProto* add_metadata_props();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
|
||
|
mutable_metadata_props();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
|
||
|
metadata_props() const;
|
||
|
|
||
|
// optional string producer_name = 2;
|
||
|
bool has_producer_name() const;
|
||
|
void clear_producer_name();
|
||
|
static const int kProducerNameFieldNumber = 2;
|
||
|
const ::std::string& producer_name() const;
|
||
|
void set_producer_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_producer_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_producer_name(const char* value);
|
||
|
void set_producer_name(const char* value, size_t size);
|
||
|
::std::string* mutable_producer_name();
|
||
|
::std::string* release_producer_name();
|
||
|
void set_allocated_producer_name(::std::string* producer_name);
|
||
|
|
||
|
// optional string producer_version = 3;
|
||
|
bool has_producer_version() const;
|
||
|
void clear_producer_version();
|
||
|
static const int kProducerVersionFieldNumber = 3;
|
||
|
const ::std::string& producer_version() const;
|
||
|
void set_producer_version(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_producer_version(::std::string&& value);
|
||
|
#endif
|
||
|
void set_producer_version(const char* value);
|
||
|
void set_producer_version(const char* value, size_t size);
|
||
|
::std::string* mutable_producer_version();
|
||
|
::std::string* release_producer_version();
|
||
|
void set_allocated_producer_version(::std::string* producer_version);
|
||
|
|
||
|
// optional string domain = 4;
|
||
|
bool has_domain() const;
|
||
|
void clear_domain();
|
||
|
static const int kDomainFieldNumber = 4;
|
||
|
const ::std::string& domain() const;
|
||
|
void set_domain(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_domain(::std::string&& value);
|
||
|
#endif
|
||
|
void set_domain(const char* value);
|
||
|
void set_domain(const char* value, size_t size);
|
||
|
::std::string* mutable_domain();
|
||
|
::std::string* release_domain();
|
||
|
void set_allocated_domain(::std::string* domain);
|
||
|
|
||
|
// optional string doc_string = 6;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 6;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// optional .opencv_onnx.GraphProto graph = 7;
|
||
|
bool has_graph() const;
|
||
|
void clear_graph();
|
||
|
static const int kGraphFieldNumber = 7;
|
||
|
const ::opencv_onnx::GraphProto& graph() const;
|
||
|
::opencv_onnx::GraphProto* release_graph();
|
||
|
::opencv_onnx::GraphProto* mutable_graph();
|
||
|
void set_allocated_graph(::opencv_onnx::GraphProto* graph);
|
||
|
|
||
|
// optional int64 ir_version = 1;
|
||
|
bool has_ir_version() const;
|
||
|
void clear_ir_version();
|
||
|
static const int kIrVersionFieldNumber = 1;
|
||
|
::google::protobuf::int64 ir_version() const;
|
||
|
void set_ir_version(::google::protobuf::int64 value);
|
||
|
|
||
|
// optional int64 model_version = 5;
|
||
|
bool has_model_version() const;
|
||
|
void clear_model_version();
|
||
|
static const int kModelVersionFieldNumber = 5;
|
||
|
::google::protobuf::int64 model_version() const;
|
||
|
void set_model_version(::google::protobuf::int64 value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.ModelProto)
|
||
|
private:
|
||
|
void set_has_ir_version();
|
||
|
void clear_has_ir_version();
|
||
|
void set_has_producer_name();
|
||
|
void clear_has_producer_name();
|
||
|
void set_has_producer_version();
|
||
|
void clear_has_producer_version();
|
||
|
void set_has_domain();
|
||
|
void clear_has_domain();
|
||
|
void set_has_model_version();
|
||
|
void clear_has_model_version();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
void set_has_graph();
|
||
|
void clear_has_graph();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto > opset_import_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto > metadata_props_;
|
||
|
::google::protobuf::internal::ArenaStringPtr producer_name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr producer_version_;
|
||
|
::google::protobuf::internal::ArenaStringPtr domain_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
::opencv_onnx::GraphProto* graph_;
|
||
|
::google::protobuf::int64 ir_version_;
|
||
|
::google::protobuf::int64 model_version_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsModelProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class StringStringEntryProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.StringStringEntryProto) */ {
|
||
|
public:
|
||
|
StringStringEntryProto();
|
||
|
virtual ~StringStringEntryProto();
|
||
|
|
||
|
StringStringEntryProto(const StringStringEntryProto& from);
|
||
|
|
||
|
inline StringStringEntryProto& operator=(const StringStringEntryProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
StringStringEntryProto(StringStringEntryProto&& from) noexcept
|
||
|
: StringStringEntryProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline StringStringEntryProto& operator=(StringStringEntryProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const StringStringEntryProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const StringStringEntryProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const StringStringEntryProto*>(
|
||
|
&_StringStringEntryProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
4;
|
||
|
|
||
|
void Swap(StringStringEntryProto* other);
|
||
|
friend void swap(StringStringEntryProto& a, StringStringEntryProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline StringStringEntryProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
StringStringEntryProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const StringStringEntryProto& from);
|
||
|
void MergeFrom(const StringStringEntryProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(StringStringEntryProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional string key = 1;
|
||
|
bool has_key() const;
|
||
|
void clear_key();
|
||
|
static const int kKeyFieldNumber = 1;
|
||
|
const ::std::string& key() const;
|
||
|
void set_key(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_key(::std::string&& value);
|
||
|
#endif
|
||
|
void set_key(const char* value);
|
||
|
void set_key(const char* value, size_t size);
|
||
|
::std::string* mutable_key();
|
||
|
::std::string* release_key();
|
||
|
void set_allocated_key(::std::string* key);
|
||
|
|
||
|
// optional string value = 2;
|
||
|
bool has_value() const;
|
||
|
void clear_value();
|
||
|
static const int kValueFieldNumber = 2;
|
||
|
const ::std::string& value() const;
|
||
|
void set_value(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_value(::std::string&& value);
|
||
|
#endif
|
||
|
void set_value(const char* value);
|
||
|
void set_value(const char* value, size_t size);
|
||
|
::std::string* mutable_value();
|
||
|
::std::string* release_value();
|
||
|
void set_allocated_value(::std::string* value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.StringStringEntryProto)
|
||
|
private:
|
||
|
void set_has_key();
|
||
|
void clear_has_key();
|
||
|
void set_has_value();
|
||
|
void clear_has_value();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr key_;
|
||
|
::google::protobuf::internal::ArenaStringPtr value_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsStringStringEntryProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class GraphProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.GraphProto) */ {
|
||
|
public:
|
||
|
GraphProto();
|
||
|
virtual ~GraphProto();
|
||
|
|
||
|
GraphProto(const GraphProto& from);
|
||
|
|
||
|
inline GraphProto& operator=(const GraphProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
GraphProto(GraphProto&& from) noexcept
|
||
|
: GraphProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline GraphProto& operator=(GraphProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const GraphProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const GraphProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const GraphProto*>(
|
||
|
&_GraphProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
5;
|
||
|
|
||
|
void Swap(GraphProto* other);
|
||
|
friend void swap(GraphProto& a, GraphProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline GraphProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
GraphProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const GraphProto& from);
|
||
|
void MergeFrom(const GraphProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(GraphProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated .opencv_onnx.NodeProto node = 1;
|
||
|
int node_size() const;
|
||
|
void clear_node();
|
||
|
static const int kNodeFieldNumber = 1;
|
||
|
const ::opencv_onnx::NodeProto& node(int index) const;
|
||
|
::opencv_onnx::NodeProto* mutable_node(int index);
|
||
|
::opencv_onnx::NodeProto* add_node();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >*
|
||
|
mutable_node();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >&
|
||
|
node() const;
|
||
|
|
||
|
// repeated .opencv_onnx.TensorProto initializer = 5;
|
||
|
int initializer_size() const;
|
||
|
void clear_initializer();
|
||
|
static const int kInitializerFieldNumber = 5;
|
||
|
const ::opencv_onnx::TensorProto& initializer(int index) const;
|
||
|
::opencv_onnx::TensorProto* mutable_initializer(int index);
|
||
|
::opencv_onnx::TensorProto* add_initializer();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
|
||
|
mutable_initializer();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
|
||
|
initializer() const;
|
||
|
|
||
|
// repeated .opencv_onnx.ValueInfoProto input = 11;
|
||
|
int input_size() const;
|
||
|
void clear_input();
|
||
|
static const int kInputFieldNumber = 11;
|
||
|
const ::opencv_onnx::ValueInfoProto& input(int index) const;
|
||
|
::opencv_onnx::ValueInfoProto* mutable_input(int index);
|
||
|
::opencv_onnx::ValueInfoProto* add_input();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
mutable_input();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
|
||
|
input() const;
|
||
|
|
||
|
// repeated .opencv_onnx.ValueInfoProto output = 12;
|
||
|
int output_size() const;
|
||
|
void clear_output();
|
||
|
static const int kOutputFieldNumber = 12;
|
||
|
const ::opencv_onnx::ValueInfoProto& output(int index) const;
|
||
|
::opencv_onnx::ValueInfoProto* mutable_output(int index);
|
||
|
::opencv_onnx::ValueInfoProto* add_output();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
mutable_output();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
|
||
|
output() const;
|
||
|
|
||
|
// repeated .opencv_onnx.ValueInfoProto value_info = 13;
|
||
|
int value_info_size() const;
|
||
|
void clear_value_info();
|
||
|
static const int kValueInfoFieldNumber = 13;
|
||
|
const ::opencv_onnx::ValueInfoProto& value_info(int index) const;
|
||
|
::opencv_onnx::ValueInfoProto* mutable_value_info(int index);
|
||
|
::opencv_onnx::ValueInfoProto* add_value_info();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
mutable_value_info();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
|
||
|
value_info() const;
|
||
|
|
||
|
// optional string name = 2;
|
||
|
bool has_name() const;
|
||
|
void clear_name();
|
||
|
static const int kNameFieldNumber = 2;
|
||
|
const ::std::string& name() const;
|
||
|
void set_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_name(const char* value);
|
||
|
void set_name(const char* value, size_t size);
|
||
|
::std::string* mutable_name();
|
||
|
::std::string* release_name();
|
||
|
void set_allocated_name(::std::string* name);
|
||
|
|
||
|
// optional string doc_string = 10;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 10;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.GraphProto)
|
||
|
private:
|
||
|
void set_has_name();
|
||
|
void clear_has_name();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto > node_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto > initializer_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > input_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > output_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto > value_info_;
|
||
|
::google::protobuf::internal::ArenaStringPtr name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TensorProto_Segment : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto.Segment) */ {
|
||
|
public:
|
||
|
TensorProto_Segment();
|
||
|
virtual ~TensorProto_Segment();
|
||
|
|
||
|
TensorProto_Segment(const TensorProto_Segment& from);
|
||
|
|
||
|
inline TensorProto_Segment& operator=(const TensorProto_Segment& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TensorProto_Segment(TensorProto_Segment&& from) noexcept
|
||
|
: TensorProto_Segment() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TensorProto_Segment& operator=(TensorProto_Segment&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TensorProto_Segment& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TensorProto_Segment* internal_default_instance() {
|
||
|
return reinterpret_cast<const TensorProto_Segment*>(
|
||
|
&_TensorProto_Segment_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
6;
|
||
|
|
||
|
void Swap(TensorProto_Segment* other);
|
||
|
friend void swap(TensorProto_Segment& a, TensorProto_Segment& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TensorProto_Segment* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TensorProto_Segment* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TensorProto_Segment& from);
|
||
|
void MergeFrom(const TensorProto_Segment& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TensorProto_Segment* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional int64 begin = 1;
|
||
|
bool has_begin() const;
|
||
|
void clear_begin();
|
||
|
static const int kBeginFieldNumber = 1;
|
||
|
::google::protobuf::int64 begin() const;
|
||
|
void set_begin(::google::protobuf::int64 value);
|
||
|
|
||
|
// optional int64 end = 2;
|
||
|
bool has_end() const;
|
||
|
void clear_end();
|
||
|
static const int kEndFieldNumber = 2;
|
||
|
::google::protobuf::int64 end() const;
|
||
|
void set_end(::google::protobuf::int64 value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto.Segment)
|
||
|
private:
|
||
|
void set_has_begin();
|
||
|
void clear_has_begin();
|
||
|
void set_has_end();
|
||
|
void clear_has_end();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::int64 begin_;
|
||
|
::google::protobuf::int64 end_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto_SegmentImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TensorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorProto) */ {
|
||
|
public:
|
||
|
TensorProto();
|
||
|
virtual ~TensorProto();
|
||
|
|
||
|
TensorProto(const TensorProto& from);
|
||
|
|
||
|
inline TensorProto& operator=(const TensorProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TensorProto(TensorProto&& from) noexcept
|
||
|
: TensorProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TensorProto& operator=(TensorProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TensorProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TensorProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const TensorProto*>(
|
||
|
&_TensorProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
7;
|
||
|
|
||
|
void Swap(TensorProto* other);
|
||
|
friend void swap(TensorProto& a, TensorProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TensorProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TensorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TensorProto& from);
|
||
|
void MergeFrom(const TensorProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TensorProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
typedef TensorProto_Segment Segment;
|
||
|
|
||
|
typedef TensorProto_DataType DataType;
|
||
|
static const DataType UNDEFINED =
|
||
|
TensorProto_DataType_UNDEFINED;
|
||
|
static const DataType FLOAT =
|
||
|
TensorProto_DataType_FLOAT;
|
||
|
static const DataType UINT8 =
|
||
|
TensorProto_DataType_UINT8;
|
||
|
static const DataType INT8 =
|
||
|
TensorProto_DataType_INT8;
|
||
|
static const DataType UINT16 =
|
||
|
TensorProto_DataType_UINT16;
|
||
|
static const DataType INT16 =
|
||
|
TensorProto_DataType_INT16;
|
||
|
static const DataType INT32 =
|
||
|
TensorProto_DataType_INT32;
|
||
|
static const DataType INT64 =
|
||
|
TensorProto_DataType_INT64;
|
||
|
static const DataType STRING =
|
||
|
TensorProto_DataType_STRING;
|
||
|
static const DataType BOOL =
|
||
|
TensorProto_DataType_BOOL;
|
||
|
static const DataType FLOAT16 =
|
||
|
TensorProto_DataType_FLOAT16;
|
||
|
static const DataType DOUBLE =
|
||
|
TensorProto_DataType_DOUBLE;
|
||
|
static const DataType UINT32 =
|
||
|
TensorProto_DataType_UINT32;
|
||
|
static const DataType UINT64 =
|
||
|
TensorProto_DataType_UINT64;
|
||
|
static const DataType COMPLEX64 =
|
||
|
TensorProto_DataType_COMPLEX64;
|
||
|
static const DataType COMPLEX128 =
|
||
|
TensorProto_DataType_COMPLEX128;
|
||
|
static inline bool DataType_IsValid(int value) {
|
||
|
return TensorProto_DataType_IsValid(value);
|
||
|
}
|
||
|
static const DataType DataType_MIN =
|
||
|
TensorProto_DataType_DataType_MIN;
|
||
|
static const DataType DataType_MAX =
|
||
|
TensorProto_DataType_DataType_MAX;
|
||
|
static const int DataType_ARRAYSIZE =
|
||
|
TensorProto_DataType_DataType_ARRAYSIZE;
|
||
|
static inline const ::google::protobuf::EnumDescriptor*
|
||
|
DataType_descriptor() {
|
||
|
return TensorProto_DataType_descriptor();
|
||
|
}
|
||
|
static inline const ::std::string& DataType_Name(DataType value) {
|
||
|
return TensorProto_DataType_Name(value);
|
||
|
}
|
||
|
static inline bool DataType_Parse(const ::std::string& name,
|
||
|
DataType* value) {
|
||
|
return TensorProto_DataType_Parse(name, value);
|
||
|
}
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated int64 dims = 1;
|
||
|
int dims_size() const;
|
||
|
void clear_dims();
|
||
|
static const int kDimsFieldNumber = 1;
|
||
|
::google::protobuf::int64 dims(int index) const;
|
||
|
void set_dims(int index, ::google::protobuf::int64 value);
|
||
|
void add_dims(::google::protobuf::int64 value);
|
||
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
dims() const;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
mutable_dims();
|
||
|
|
||
|
// repeated float float_data = 4 [packed = true];
|
||
|
int float_data_size() const;
|
||
|
void clear_float_data();
|
||
|
static const int kFloatDataFieldNumber = 4;
|
||
|
float float_data(int index) const;
|
||
|
void set_float_data(int index, float value);
|
||
|
void add_float_data(float value);
|
||
|
const ::google::protobuf::RepeatedField< float >&
|
||
|
float_data() const;
|
||
|
::google::protobuf::RepeatedField< float >*
|
||
|
mutable_float_data();
|
||
|
|
||
|
// repeated int32 int32_data = 5 [packed = true];
|
||
|
int int32_data_size() const;
|
||
|
void clear_int32_data();
|
||
|
static const int kInt32DataFieldNumber = 5;
|
||
|
::google::protobuf::int32 int32_data(int index) const;
|
||
|
void set_int32_data(int index, ::google::protobuf::int32 value);
|
||
|
void add_int32_data(::google::protobuf::int32 value);
|
||
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
|
||
|
int32_data() const;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
|
||
|
mutable_int32_data();
|
||
|
|
||
|
// repeated bytes string_data = 6;
|
||
|
int string_data_size() const;
|
||
|
void clear_string_data();
|
||
|
static const int kStringDataFieldNumber = 6;
|
||
|
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);
|
||
|
#if LANG_CXX11
|
||
|
void set_string_data(int index, ::std::string&& value);
|
||
|
#endif
|
||
|
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);
|
||
|
#if LANG_CXX11
|
||
|
void add_string_data(::std::string&& value);
|
||
|
#endif
|
||
|
void add_string_data(const char* value);
|
||
|
void add_string_data(const void* value, size_t size);
|
||
|
const ::google::protobuf::RepeatedPtrField< ::std::string>& string_data() const;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_string_data();
|
||
|
|
||
|
// repeated int64 int64_data = 7 [packed = true];
|
||
|
int int64_data_size() const;
|
||
|
void clear_int64_data();
|
||
|
static const int kInt64DataFieldNumber = 7;
|
||
|
::google::protobuf::int64 int64_data(int index) const;
|
||
|
void set_int64_data(int index, ::google::protobuf::int64 value);
|
||
|
void add_int64_data(::google::protobuf::int64 value);
|
||
|
const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
int64_data() const;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
mutable_int64_data();
|
||
|
|
||
|
// repeated double double_data = 10 [packed = true];
|
||
|
int double_data_size() const;
|
||
|
void clear_double_data();
|
||
|
static const int kDoubleDataFieldNumber = 10;
|
||
|
double double_data(int index) const;
|
||
|
void set_double_data(int index, double value);
|
||
|
void add_double_data(double value);
|
||
|
const ::google::protobuf::RepeatedField< double >&
|
||
|
double_data() const;
|
||
|
::google::protobuf::RepeatedField< double >*
|
||
|
mutable_double_data();
|
||
|
|
||
|
// repeated uint64 uint64_data = 11 [packed = true];
|
||
|
int uint64_data_size() const;
|
||
|
void clear_uint64_data();
|
||
|
static const int kUint64DataFieldNumber = 11;
|
||
|
::google::protobuf::uint64 uint64_data(int index) const;
|
||
|
void set_uint64_data(int index, ::google::protobuf::uint64 value);
|
||
|
void add_uint64_data(::google::protobuf::uint64 value);
|
||
|
const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
|
||
|
uint64_data() const;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
|
||
|
mutable_uint64_data();
|
||
|
|
||
|
// optional string name = 8;
|
||
|
bool has_name() const;
|
||
|
void clear_name();
|
||
|
static const int kNameFieldNumber = 8;
|
||
|
const ::std::string& name() const;
|
||
|
void set_name(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_name(::std::string&& value);
|
||
|
#endif
|
||
|
void set_name(const char* value);
|
||
|
void set_name(const char* value, size_t size);
|
||
|
::std::string* mutable_name();
|
||
|
::std::string* release_name();
|
||
|
void set_allocated_name(::std::string* name);
|
||
|
|
||
|
// optional bytes raw_data = 9;
|
||
|
bool has_raw_data() const;
|
||
|
void clear_raw_data();
|
||
|
static const int kRawDataFieldNumber = 9;
|
||
|
const ::std::string& raw_data() const;
|
||
|
void set_raw_data(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_raw_data(::std::string&& value);
|
||
|
#endif
|
||
|
void set_raw_data(const char* value);
|
||
|
void set_raw_data(const void* value, size_t size);
|
||
|
::std::string* mutable_raw_data();
|
||
|
::std::string* release_raw_data();
|
||
|
void set_allocated_raw_data(::std::string* raw_data);
|
||
|
|
||
|
// optional string doc_string = 12;
|
||
|
bool has_doc_string() const;
|
||
|
void clear_doc_string();
|
||
|
static const int kDocStringFieldNumber = 12;
|
||
|
const ::std::string& doc_string() const;
|
||
|
void set_doc_string(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_doc_string(::std::string&& value);
|
||
|
#endif
|
||
|
void set_doc_string(const char* value);
|
||
|
void set_doc_string(const char* value, size_t size);
|
||
|
::std::string* mutable_doc_string();
|
||
|
::std::string* release_doc_string();
|
||
|
void set_allocated_doc_string(::std::string* doc_string);
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.Segment segment = 3;
|
||
|
bool has_segment() const;
|
||
|
void clear_segment();
|
||
|
static const int kSegmentFieldNumber = 3;
|
||
|
const ::opencv_onnx::TensorProto_Segment& segment() const;
|
||
|
::opencv_onnx::TensorProto_Segment* release_segment();
|
||
|
::opencv_onnx::TensorProto_Segment* mutable_segment();
|
||
|
void set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment);
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.DataType data_type = 2;
|
||
|
bool has_data_type() const;
|
||
|
void clear_data_type();
|
||
|
static const int kDataTypeFieldNumber = 2;
|
||
|
::opencv_onnx::TensorProto_DataType data_type() const;
|
||
|
void set_data_type(::opencv_onnx::TensorProto_DataType value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorProto)
|
||
|
private:
|
||
|
void set_has_data_type();
|
||
|
void clear_has_data_type();
|
||
|
void set_has_segment();
|
||
|
void clear_has_segment();
|
||
|
void set_has_name();
|
||
|
void clear_has_name();
|
||
|
void set_has_doc_string();
|
||
|
void clear_has_doc_string();
|
||
|
void set_has_raw_data();
|
||
|
void clear_has_raw_data();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 > dims_;
|
||
|
::google::protobuf::RepeatedField< float > float_data_;
|
||
|
mutable int _float_data_cached_byte_size_;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int32 > int32_data_;
|
||
|
mutable int _int32_data_cached_byte_size_;
|
||
|
::google::protobuf::RepeatedPtrField< ::std::string> string_data_;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::int64 > int64_data_;
|
||
|
mutable int _int64_data_cached_byte_size_;
|
||
|
::google::protobuf::RepeatedField< double > double_data_;
|
||
|
mutable int _double_data_cached_byte_size_;
|
||
|
::google::protobuf::RepeatedField< ::google::protobuf::uint64 > uint64_data_;
|
||
|
mutable int _uint64_data_cached_byte_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr name_;
|
||
|
::google::protobuf::internal::ArenaStringPtr raw_data_;
|
||
|
::google::protobuf::internal::ArenaStringPtr doc_string_;
|
||
|
::opencv_onnx::TensorProto_Segment* segment_;
|
||
|
int data_type_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TensorShapeProto_Dimension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto.Dimension) */ {
|
||
|
public:
|
||
|
TensorShapeProto_Dimension();
|
||
|
virtual ~TensorShapeProto_Dimension();
|
||
|
|
||
|
TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from);
|
||
|
|
||
|
inline TensorShapeProto_Dimension& operator=(const TensorShapeProto_Dimension& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TensorShapeProto_Dimension(TensorShapeProto_Dimension&& from) noexcept
|
||
|
: TensorShapeProto_Dimension() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TensorShapeProto_Dimension& operator=(TensorShapeProto_Dimension&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TensorShapeProto_Dimension& default_instance();
|
||
|
|
||
|
enum ValueCase {
|
||
|
kDimValue = 1,
|
||
|
kDimParam = 2,
|
||
|
VALUE_NOT_SET = 0,
|
||
|
};
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TensorShapeProto_Dimension* internal_default_instance() {
|
||
|
return reinterpret_cast<const TensorShapeProto_Dimension*>(
|
||
|
&_TensorShapeProto_Dimension_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
8;
|
||
|
|
||
|
void Swap(TensorShapeProto_Dimension* other);
|
||
|
friend void swap(TensorShapeProto_Dimension& a, TensorShapeProto_Dimension& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TensorShapeProto_Dimension* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TensorShapeProto_Dimension* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TensorShapeProto_Dimension& from);
|
||
|
void MergeFrom(const TensorShapeProto_Dimension& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TensorShapeProto_Dimension* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional string denotation = 3;
|
||
|
bool has_denotation() const;
|
||
|
void clear_denotation();
|
||
|
static const int kDenotationFieldNumber = 3;
|
||
|
const ::std::string& denotation() const;
|
||
|
void set_denotation(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_denotation(::std::string&& value);
|
||
|
#endif
|
||
|
void set_denotation(const char* value);
|
||
|
void set_denotation(const char* value, size_t size);
|
||
|
::std::string* mutable_denotation();
|
||
|
::std::string* release_denotation();
|
||
|
void set_allocated_denotation(::std::string* denotation);
|
||
|
|
||
|
// optional int64 dim_value = 1;
|
||
|
bool has_dim_value() const;
|
||
|
void clear_dim_value();
|
||
|
static const int kDimValueFieldNumber = 1;
|
||
|
::google::protobuf::int64 dim_value() const;
|
||
|
void set_dim_value(::google::protobuf::int64 value);
|
||
|
|
||
|
// optional string dim_param = 2;
|
||
|
bool has_dim_param() const;
|
||
|
void clear_dim_param();
|
||
|
static const int kDimParamFieldNumber = 2;
|
||
|
const ::std::string& dim_param() const;
|
||
|
void set_dim_param(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_dim_param(::std::string&& value);
|
||
|
#endif
|
||
|
void set_dim_param(const char* value);
|
||
|
void set_dim_param(const char* value, size_t size);
|
||
|
::std::string* mutable_dim_param();
|
||
|
::std::string* release_dim_param();
|
||
|
void set_allocated_dim_param(::std::string* dim_param);
|
||
|
|
||
|
ValueCase value_case() const;
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto.Dimension)
|
||
|
private:
|
||
|
void set_has_dim_value();
|
||
|
void set_has_dim_param();
|
||
|
void set_has_denotation();
|
||
|
void clear_has_denotation();
|
||
|
|
||
|
inline bool has_value() const;
|
||
|
void clear_value();
|
||
|
inline void clear_has_value();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr denotation_;
|
||
|
union ValueUnion {
|
||
|
ValueUnion() {}
|
||
|
::google::protobuf::int64 dim_value_;
|
||
|
::google::protobuf::internal::ArenaStringPtr dim_param_;
|
||
|
} value_;
|
||
|
::google::protobuf::uint32 _oneof_case_[1];
|
||
|
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto_DimensionImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TensorShapeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TensorShapeProto) */ {
|
||
|
public:
|
||
|
TensorShapeProto();
|
||
|
virtual ~TensorShapeProto();
|
||
|
|
||
|
TensorShapeProto(const TensorShapeProto& from);
|
||
|
|
||
|
inline TensorShapeProto& operator=(const TensorShapeProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TensorShapeProto(TensorShapeProto&& from) noexcept
|
||
|
: TensorShapeProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TensorShapeProto& operator=(TensorShapeProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TensorShapeProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TensorShapeProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const TensorShapeProto*>(
|
||
|
&_TensorShapeProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
9;
|
||
|
|
||
|
void Swap(TensorShapeProto* other);
|
||
|
friend void swap(TensorShapeProto& a, TensorShapeProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TensorShapeProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TensorShapeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TensorShapeProto& from);
|
||
|
void MergeFrom(const TensorShapeProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TensorShapeProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
typedef TensorShapeProto_Dimension Dimension;
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1;
|
||
|
int dim_size() const;
|
||
|
void clear_dim();
|
||
|
static const int kDimFieldNumber = 1;
|
||
|
const ::opencv_onnx::TensorShapeProto_Dimension& dim(int index) const;
|
||
|
::opencv_onnx::TensorShapeProto_Dimension* mutable_dim(int index);
|
||
|
::opencv_onnx::TensorShapeProto_Dimension* add_dim();
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
|
||
|
mutable_dim();
|
||
|
const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
|
||
|
dim() const;
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TensorShapeProto)
|
||
|
private:
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension > dim_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TypeProto_Tensor : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto.Tensor) */ {
|
||
|
public:
|
||
|
TypeProto_Tensor();
|
||
|
virtual ~TypeProto_Tensor();
|
||
|
|
||
|
TypeProto_Tensor(const TypeProto_Tensor& from);
|
||
|
|
||
|
inline TypeProto_Tensor& operator=(const TypeProto_Tensor& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TypeProto_Tensor(TypeProto_Tensor&& from) noexcept
|
||
|
: TypeProto_Tensor() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TypeProto_Tensor& operator=(TypeProto_Tensor&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TypeProto_Tensor& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TypeProto_Tensor* internal_default_instance() {
|
||
|
return reinterpret_cast<const TypeProto_Tensor*>(
|
||
|
&_TypeProto_Tensor_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
10;
|
||
|
|
||
|
void Swap(TypeProto_Tensor* other);
|
||
|
friend void swap(TypeProto_Tensor& a, TypeProto_Tensor& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TypeProto_Tensor* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TypeProto_Tensor* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TypeProto_Tensor& from);
|
||
|
void MergeFrom(const TypeProto_Tensor& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TypeProto_Tensor* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional .opencv_onnx.TensorShapeProto shape = 2;
|
||
|
bool has_shape() const;
|
||
|
void clear_shape();
|
||
|
static const int kShapeFieldNumber = 2;
|
||
|
const ::opencv_onnx::TensorShapeProto& shape() const;
|
||
|
::opencv_onnx::TensorShapeProto* release_shape();
|
||
|
::opencv_onnx::TensorShapeProto* mutable_shape();
|
||
|
void set_allocated_shape(::opencv_onnx::TensorShapeProto* shape);
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.DataType elem_type = 1;
|
||
|
bool has_elem_type() const;
|
||
|
void clear_elem_type();
|
||
|
static const int kElemTypeFieldNumber = 1;
|
||
|
::opencv_onnx::TensorProto_DataType elem_type() const;
|
||
|
void set_elem_type(::opencv_onnx::TensorProto_DataType value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto.Tensor)
|
||
|
private:
|
||
|
void set_has_elem_type();
|
||
|
void clear_has_elem_type();
|
||
|
void set_has_shape();
|
||
|
void clear_has_shape();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::opencv_onnx::TensorShapeProto* shape_;
|
||
|
int elem_type_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto_TensorImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class TypeProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.TypeProto) */ {
|
||
|
public:
|
||
|
TypeProto();
|
||
|
virtual ~TypeProto();
|
||
|
|
||
|
TypeProto(const TypeProto& from);
|
||
|
|
||
|
inline TypeProto& operator=(const TypeProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
TypeProto(TypeProto&& from) noexcept
|
||
|
: TypeProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline TypeProto& operator=(TypeProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const TypeProto& default_instance();
|
||
|
|
||
|
enum ValueCase {
|
||
|
kTensorType = 1,
|
||
|
VALUE_NOT_SET = 0,
|
||
|
};
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const TypeProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const TypeProto*>(
|
||
|
&_TypeProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
11;
|
||
|
|
||
|
void Swap(TypeProto* other);
|
||
|
friend void swap(TypeProto& a, TypeProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline TypeProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
TypeProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const TypeProto& from);
|
||
|
void MergeFrom(const TypeProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(TypeProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
typedef TypeProto_Tensor Tensor;
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional string denotation = 6;
|
||
|
bool has_denotation() const;
|
||
|
void clear_denotation();
|
||
|
static const int kDenotationFieldNumber = 6;
|
||
|
const ::std::string& denotation() const;
|
||
|
void set_denotation(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_denotation(::std::string&& value);
|
||
|
#endif
|
||
|
void set_denotation(const char* value);
|
||
|
void set_denotation(const char* value, size_t size);
|
||
|
::std::string* mutable_denotation();
|
||
|
::std::string* release_denotation();
|
||
|
void set_allocated_denotation(::std::string* denotation);
|
||
|
|
||
|
// optional .opencv_onnx.TypeProto.Tensor tensor_type = 1;
|
||
|
bool has_tensor_type() const;
|
||
|
void clear_tensor_type();
|
||
|
static const int kTensorTypeFieldNumber = 1;
|
||
|
const ::opencv_onnx::TypeProto_Tensor& tensor_type() const;
|
||
|
::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);
|
||
|
|
||
|
ValueCase value_case() const;
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.TypeProto)
|
||
|
private:
|
||
|
void set_has_tensor_type();
|
||
|
void set_has_denotation();
|
||
|
void clear_has_denotation();
|
||
|
|
||
|
inline bool has_value() const;
|
||
|
void clear_value();
|
||
|
inline void clear_has_value();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr denotation_;
|
||
|
union ValueUnion {
|
||
|
ValueUnion() {}
|
||
|
::opencv_onnx::TypeProto_Tensor* tensor_type_;
|
||
|
} value_;
|
||
|
::google::protobuf::uint32 _oneof_case_[1];
|
||
|
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProtoImpl();
|
||
|
};
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
class OperatorSetIdProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:opencv_onnx.OperatorSetIdProto) */ {
|
||
|
public:
|
||
|
OperatorSetIdProto();
|
||
|
virtual ~OperatorSetIdProto();
|
||
|
|
||
|
OperatorSetIdProto(const OperatorSetIdProto& from);
|
||
|
|
||
|
inline OperatorSetIdProto& operator=(const OperatorSetIdProto& from) {
|
||
|
CopyFrom(from);
|
||
|
return *this;
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
OperatorSetIdProto(OperatorSetIdProto&& from) noexcept
|
||
|
: OperatorSetIdProto() {
|
||
|
*this = ::std::move(from);
|
||
|
}
|
||
|
|
||
|
inline OperatorSetIdProto& operator=(OperatorSetIdProto&& from) noexcept {
|
||
|
if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
|
||
|
if (this != &from) InternalSwap(&from);
|
||
|
} else {
|
||
|
CopyFrom(from);
|
||
|
}
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
|
||
|
return _internal_metadata_.unknown_fields();
|
||
|
}
|
||
|
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
|
||
|
return _internal_metadata_.mutable_unknown_fields();
|
||
|
}
|
||
|
|
||
|
static const ::google::protobuf::Descriptor* descriptor();
|
||
|
static const OperatorSetIdProto& default_instance();
|
||
|
|
||
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
||
|
static inline const OperatorSetIdProto* internal_default_instance() {
|
||
|
return reinterpret_cast<const OperatorSetIdProto*>(
|
||
|
&_OperatorSetIdProto_default_instance_);
|
||
|
}
|
||
|
static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
|
||
|
12;
|
||
|
|
||
|
void Swap(OperatorSetIdProto* other);
|
||
|
friend void swap(OperatorSetIdProto& a, OperatorSetIdProto& b) {
|
||
|
a.Swap(&b);
|
||
|
}
|
||
|
|
||
|
// implements Message ----------------------------------------------
|
||
|
|
||
|
inline OperatorSetIdProto* New() const PROTOBUF_FINAL { return New(NULL); }
|
||
|
|
||
|
OperatorSetIdProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
|
||
|
void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
|
||
|
void CopyFrom(const OperatorSetIdProto& from);
|
||
|
void MergeFrom(const OperatorSetIdProto& from);
|
||
|
void Clear() PROTOBUF_FINAL;
|
||
|
bool IsInitialized() const PROTOBUF_FINAL;
|
||
|
|
||
|
size_t ByteSizeLong() const PROTOBUF_FINAL;
|
||
|
bool MergePartialFromCodedStream(
|
||
|
::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
|
||
|
void SerializeWithCachedSizes(
|
||
|
::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
|
||
|
::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
|
||
|
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
|
||
|
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
|
||
|
private:
|
||
|
void SharedCtor();
|
||
|
void SharedDtor();
|
||
|
void SetCachedSize(int size) const PROTOBUF_FINAL;
|
||
|
void InternalSwap(OperatorSetIdProto* other);
|
||
|
private:
|
||
|
inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
inline void* MaybeArenaPtr() const {
|
||
|
return NULL;
|
||
|
}
|
||
|
public:
|
||
|
|
||
|
::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
|
||
|
|
||
|
// nested types ----------------------------------------------------
|
||
|
|
||
|
// accessors -------------------------------------------------------
|
||
|
|
||
|
// optional string domain = 1;
|
||
|
bool has_domain() const;
|
||
|
void clear_domain();
|
||
|
static const int kDomainFieldNumber = 1;
|
||
|
const ::std::string& domain() const;
|
||
|
void set_domain(const ::std::string& value);
|
||
|
#if LANG_CXX11
|
||
|
void set_domain(::std::string&& value);
|
||
|
#endif
|
||
|
void set_domain(const char* value);
|
||
|
void set_domain(const char* value, size_t size);
|
||
|
::std::string* mutable_domain();
|
||
|
::std::string* release_domain();
|
||
|
void set_allocated_domain(::std::string* domain);
|
||
|
|
||
|
// optional int64 version = 2;
|
||
|
bool has_version() const;
|
||
|
void clear_version();
|
||
|
static const int kVersionFieldNumber = 2;
|
||
|
::google::protobuf::int64 version() const;
|
||
|
void set_version(::google::protobuf::int64 value);
|
||
|
|
||
|
// @@protoc_insertion_point(class_scope:opencv_onnx.OperatorSetIdProto)
|
||
|
private:
|
||
|
void set_has_domain();
|
||
|
void clear_has_domain();
|
||
|
void set_has_version();
|
||
|
void clear_has_version();
|
||
|
|
||
|
::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
|
||
|
::google::protobuf::internal::HasBits<1> _has_bits_;
|
||
|
mutable int _cached_size_;
|
||
|
::google::protobuf::internal::ArenaStringPtr domain_;
|
||
|
::google::protobuf::int64 version_;
|
||
|
friend struct ::protobuf_opencv_2donnx_2eproto::TableStruct;
|
||
|
friend void ::protobuf_opencv_2donnx_2eproto::InitDefaultsOperatorSetIdProtoImpl();
|
||
|
};
|
||
|
// ===================================================================
|
||
|
|
||
|
|
||
|
// ===================================================================
|
||
|
|
||
|
#ifdef __GNUC__
|
||
|
#pragma GCC diagnostic push
|
||
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
||
|
#endif // __GNUC__
|
||
|
// AttributeProto
|
||
|
|
||
|
// optional string name = 1;
|
||
|
inline bool AttributeProto::has_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_name() {
|
||
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_name();
|
||
|
}
|
||
|
inline const ::std::string& AttributeProto::name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.name)
|
||
|
return name_.GetNoArena();
|
||
|
}
|
||
|
inline void AttributeProto::set_name(const ::std::string& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::set_name(::std::string&& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::set_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.name)
|
||
|
}
|
||
|
inline void AttributeProto::set_name(const char* value, size_t size) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.name)
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::mutable_name() {
|
||
|
set_has_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.name)
|
||
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::release_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.name)
|
||
|
clear_has_name();
|
||
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_name(::std::string* name) {
|
||
|
if (name != NULL) {
|
||
|
set_has_name();
|
||
|
} else {
|
||
|
clear_has_name();
|
||
|
}
|
||
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.name)
|
||
|
}
|
||
|
|
||
|
// optional string ref_attr_name = 21;
|
||
|
inline bool AttributeProto::has_ref_attr_name() const {
|
||
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_ref_attr_name() {
|
||
|
_has_bits_[0] |= 0x00000008u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_ref_attr_name() {
|
||
|
_has_bits_[0] &= ~0x00000008u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_ref_attr_name() {
|
||
|
ref_attr_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_ref_attr_name();
|
||
|
}
|
||
|
inline const ::std::string& AttributeProto::ref_attr_name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
return ref_attr_name_.GetNoArena();
|
||
|
}
|
||
|
inline void AttributeProto::set_ref_attr_name(const ::std::string& value) {
|
||
|
set_has_ref_attr_name();
|
||
|
ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::set_ref_attr_name(::std::string&& value) {
|
||
|
set_has_ref_attr_name();
|
||
|
ref_attr_name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::set_ref_attr_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_ref_attr_name();
|
||
|
ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
}
|
||
|
inline void AttributeProto::set_ref_attr_name(const char* value, size_t size) {
|
||
|
set_has_ref_attr_name();
|
||
|
ref_attr_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::mutable_ref_attr_name() {
|
||
|
set_has_ref_attr_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
return ref_attr_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::release_ref_attr_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
clear_has_ref_attr_name();
|
||
|
return ref_attr_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_ref_attr_name(::std::string* ref_attr_name) {
|
||
|
if (ref_attr_name != NULL) {
|
||
|
set_has_ref_attr_name();
|
||
|
} else {
|
||
|
clear_has_ref_attr_name();
|
||
|
}
|
||
|
ref_attr_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ref_attr_name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.ref_attr_name)
|
||
|
}
|
||
|
|
||
|
// optional string doc_string = 13;
|
||
|
inline bool AttributeProto::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000004u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000004u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& AttributeProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void AttributeProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.doc_string)
|
||
|
}
|
||
|
inline void AttributeProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.AttributeProto.AttributeType type = 20;
|
||
|
inline bool AttributeProto::has_type() const {
|
||
|
return (_has_bits_[0] & 0x00000100u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_type() {
|
||
|
_has_bits_[0] |= 0x00000100u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_type() {
|
||
|
_has_bits_[0] &= ~0x00000100u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_type() {
|
||
|
type_ = 0;
|
||
|
clear_has_type();
|
||
|
}
|
||
|
inline ::opencv_onnx::AttributeProto_AttributeType AttributeProto::type() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.type)
|
||
|
return static_cast< ::opencv_onnx::AttributeProto_AttributeType >(type_);
|
||
|
}
|
||
|
inline void AttributeProto::set_type(::opencv_onnx::AttributeProto_AttributeType value) {
|
||
|
assert(::opencv_onnx::AttributeProto_AttributeType_IsValid(value));
|
||
|
set_has_type();
|
||
|
type_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.type)
|
||
|
}
|
||
|
|
||
|
// optional float f = 2;
|
||
|
inline bool AttributeProto::has_f() const {
|
||
|
return (_has_bits_[0] & 0x00000080u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_f() {
|
||
|
_has_bits_[0] |= 0x00000080u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_f() {
|
||
|
_has_bits_[0] &= ~0x00000080u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_f() {
|
||
|
f_ = 0;
|
||
|
clear_has_f();
|
||
|
}
|
||
|
inline float AttributeProto::f() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.f)
|
||
|
return f_;
|
||
|
}
|
||
|
inline void AttributeProto::set_f(float value) {
|
||
|
set_has_f();
|
||
|
f_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.f)
|
||
|
}
|
||
|
|
||
|
// optional int64 i = 3;
|
||
|
inline bool AttributeProto::has_i() const {
|
||
|
return (_has_bits_[0] & 0x00000040u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_i() {
|
||
|
_has_bits_[0] |= 0x00000040u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_i() {
|
||
|
_has_bits_[0] &= ~0x00000040u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_i() {
|
||
|
i_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_i();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 AttributeProto::i() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.i)
|
||
|
return i_;
|
||
|
}
|
||
|
inline void AttributeProto::set_i(::google::protobuf::int64 value) {
|
||
|
set_has_i();
|
||
|
i_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.i)
|
||
|
}
|
||
|
|
||
|
// optional bytes s = 4;
|
||
|
inline bool AttributeProto::has_s() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_s() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_s() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_s() {
|
||
|
s_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_s();
|
||
|
}
|
||
|
inline const ::std::string& AttributeProto::s() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.s)
|
||
|
return s_.GetNoArena();
|
||
|
}
|
||
|
inline void AttributeProto::set_s(const ::std::string& value) {
|
||
|
set_has_s();
|
||
|
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.s)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::set_s(::std::string&& value) {
|
||
|
set_has_s();
|
||
|
s_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.AttributeProto.s)
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::set_s(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_s();
|
||
|
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.AttributeProto.s)
|
||
|
}
|
||
|
inline void AttributeProto::set_s(const void* value, size_t size) {
|
||
|
set_has_s();
|
||
|
s_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.AttributeProto.s)
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::mutable_s() {
|
||
|
set_has_s();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.s)
|
||
|
return s_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* AttributeProto::release_s() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.s)
|
||
|
clear_has_s();
|
||
|
return s_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_s(::std::string* s) {
|
||
|
if (s != NULL) {
|
||
|
set_has_s();
|
||
|
} else {
|
||
|
clear_has_s();
|
||
|
}
|
||
|
s_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), s);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.s)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto t = 5;
|
||
|
inline bool AttributeProto::has_t() const {
|
||
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_t() {
|
||
|
_has_bits_[0] |= 0x00000010u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_t() {
|
||
|
_has_bits_[0] &= ~0x00000010u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_t() {
|
||
|
if (t_ != NULL) t_->Clear();
|
||
|
clear_has_t();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorProto& AttributeProto::t() const {
|
||
|
const ::opencv_onnx::TensorProto* p = t_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.t)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorProto*>(
|
||
|
&::opencv_onnx::_TensorProto_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* AttributeProto::release_t() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.t)
|
||
|
clear_has_t();
|
||
|
::opencv_onnx::TensorProto* temp = t_;
|
||
|
t_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* AttributeProto::mutable_t() {
|
||
|
set_has_t();
|
||
|
if (t_ == NULL) {
|
||
|
t_ = new ::opencv_onnx::TensorProto;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.t)
|
||
|
return t_;
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_t(::opencv_onnx::TensorProto* t) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete t_;
|
||
|
}
|
||
|
if (t) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
t = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, t, submessage_arena);
|
||
|
}
|
||
|
set_has_t();
|
||
|
} else {
|
||
|
clear_has_t();
|
||
|
}
|
||
|
t_ = t;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.t)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.GraphProto g = 6;
|
||
|
inline bool AttributeProto::has_g() const {
|
||
|
return (_has_bits_[0] & 0x00000020u) != 0;
|
||
|
}
|
||
|
inline void AttributeProto::set_has_g() {
|
||
|
_has_bits_[0] |= 0x00000020u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_has_g() {
|
||
|
_has_bits_[0] &= ~0x00000020u;
|
||
|
}
|
||
|
inline void AttributeProto::clear_g() {
|
||
|
if (g_ != NULL) g_->Clear();
|
||
|
clear_has_g();
|
||
|
}
|
||
|
inline const ::opencv_onnx::GraphProto& AttributeProto::g() const {
|
||
|
const ::opencv_onnx::GraphProto* p = g_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.g)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::GraphProto*>(
|
||
|
&::opencv_onnx::_GraphProto_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* AttributeProto::release_g() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.AttributeProto.g)
|
||
|
clear_has_g();
|
||
|
::opencv_onnx::GraphProto* temp = g_;
|
||
|
g_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* AttributeProto::mutable_g() {
|
||
|
set_has_g();
|
||
|
if (g_ == NULL) {
|
||
|
g_ = new ::opencv_onnx::GraphProto;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.g)
|
||
|
return g_;
|
||
|
}
|
||
|
inline void AttributeProto::set_allocated_g(::opencv_onnx::GraphProto* g) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete g_;
|
||
|
}
|
||
|
if (g) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
g = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, g, submessage_arena);
|
||
|
}
|
||
|
set_has_g();
|
||
|
} else {
|
||
|
clear_has_g();
|
||
|
}
|
||
|
g_ = g;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.AttributeProto.g)
|
||
|
}
|
||
|
|
||
|
// repeated float floats = 7;
|
||
|
inline int AttributeProto::floats_size() const {
|
||
|
return floats_.size();
|
||
|
}
|
||
|
inline void AttributeProto::clear_floats() {
|
||
|
floats_.Clear();
|
||
|
}
|
||
|
inline float AttributeProto::floats(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.floats)
|
||
|
return floats_.Get(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::add_floats(float value) {
|
||
|
floats_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.floats)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< float >&
|
||
|
AttributeProto::floats() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.floats)
|
||
|
return floats_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< float >*
|
||
|
AttributeProto::mutable_floats() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.floats)
|
||
|
return &floats_;
|
||
|
}
|
||
|
|
||
|
// repeated int64 ints = 8;
|
||
|
inline int AttributeProto::ints_size() const {
|
||
|
return ints_.size();
|
||
|
}
|
||
|
inline void AttributeProto::clear_ints() {
|
||
|
ints_.Clear();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 AttributeProto::ints(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.ints)
|
||
|
return ints_.Get(index);
|
||
|
}
|
||
|
inline void AttributeProto::set_ints(int index, ::google::protobuf::int64 value) {
|
||
|
ints_.Set(index, value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.ints)
|
||
|
}
|
||
|
inline void AttributeProto::add_ints(::google::protobuf::int64 value) {
|
||
|
ints_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.ints)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
AttributeProto::ints() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.ints)
|
||
|
return ints_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
AttributeProto::mutable_ints() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.ints)
|
||
|
return &ints_;
|
||
|
}
|
||
|
|
||
|
// repeated bytes strings = 9;
|
||
|
inline int AttributeProto::strings_size() const {
|
||
|
return strings_.size();
|
||
|
}
|
||
|
inline void AttributeProto::clear_strings() {
|
||
|
strings_.Clear();
|
||
|
}
|
||
|
inline const ::std::string& AttributeProto::strings(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.strings)
|
||
|
return strings_.Get(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) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
|
||
|
strings_.Mutable(index)->assign(value);
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::set_strings(int index, ::std::string&& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.AttributeProto.strings)
|
||
|
strings_.Mutable(index)->assign(std::move(value));
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::set_strings(int index, const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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::add_strings() {
|
||
|
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.AttributeProto.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)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void AttributeProto::add_strings(::std::string&& value) {
|
||
|
strings_.Add(std::move(value));
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.strings)
|
||
|
}
|
||
|
#endif
|
||
|
inline void AttributeProto::add_strings(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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 ::google::protobuf::RepeatedPtrField< ::std::string>&
|
||
|
AttributeProto::strings() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.strings)
|
||
|
return strings_;
|
||
|
}
|
||
|
inline ::google::protobuf::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::tensors_size() const {
|
||
|
return tensors_.size();
|
||
|
}
|
||
|
inline void AttributeProto::clear_tensors() {
|
||
|
tensors_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorProto& AttributeProto::tensors(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.tensors)
|
||
|
return tensors_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* AttributeProto::mutable_tensors(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.tensors)
|
||
|
return tensors_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* AttributeProto::add_tensors() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.tensors)
|
||
|
return tensors_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
|
||
|
AttributeProto::mutable_tensors() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.tensors)
|
||
|
return &tensors_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::graphs_size() const {
|
||
|
return graphs_.size();
|
||
|
}
|
||
|
inline void AttributeProto::clear_graphs() {
|
||
|
graphs_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::GraphProto& AttributeProto::graphs(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.AttributeProto.graphs)
|
||
|
return graphs_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* AttributeProto::mutable_graphs(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.AttributeProto.graphs)
|
||
|
return graphs_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* AttributeProto::add_graphs() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.AttributeProto.graphs)
|
||
|
return graphs_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >*
|
||
|
AttributeProto::mutable_graphs() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.AttributeProto.graphs)
|
||
|
return &graphs_;
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::GraphProto >&
|
||
|
AttributeProto::graphs() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.AttributeProto.graphs)
|
||
|
return graphs_;
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// ValueInfoProto
|
||
|
|
||
|
// optional string name = 1;
|
||
|
inline bool ValueInfoProto::has_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void ValueInfoProto::set_has_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_has_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_name() {
|
||
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_name();
|
||
|
}
|
||
|
inline const ::std::string& ValueInfoProto::name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.name)
|
||
|
return name_.GetNoArena();
|
||
|
}
|
||
|
inline void ValueInfoProto::set_name(const ::std::string& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ValueInfoProto::set_name(::std::string&& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ValueInfoProto.name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ValueInfoProto::set_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ValueInfoProto.name)
|
||
|
}
|
||
|
inline void ValueInfoProto::set_name(const char* value, size_t size) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ValueInfoProto.name)
|
||
|
}
|
||
|
inline ::std::string* ValueInfoProto::mutable_name() {
|
||
|
set_has_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.name)
|
||
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ValueInfoProto::release_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.name)
|
||
|
clear_has_name();
|
||
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ValueInfoProto::set_allocated_name(::std::string* name) {
|
||
|
if (name != NULL) {
|
||
|
set_has_name();
|
||
|
} else {
|
||
|
clear_has_name();
|
||
|
}
|
||
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.name)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.TypeProto type = 2;
|
||
|
inline bool ValueInfoProto::has_type() const {
|
||
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
||
|
}
|
||
|
inline void ValueInfoProto::set_has_type() {
|
||
|
_has_bits_[0] |= 0x00000004u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_has_type() {
|
||
|
_has_bits_[0] &= ~0x00000004u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_type() {
|
||
|
if (type_ != NULL) type_->Clear();
|
||
|
clear_has_type();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TypeProto& ValueInfoProto::type() const {
|
||
|
const ::opencv_onnx::TypeProto* p = type_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.type)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TypeProto*>(
|
||
|
&::opencv_onnx::_TypeProto_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::TypeProto* ValueInfoProto::release_type() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.type)
|
||
|
clear_has_type();
|
||
|
::opencv_onnx::TypeProto* temp = type_;
|
||
|
type_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::TypeProto* ValueInfoProto::mutable_type() {
|
||
|
set_has_type();
|
||
|
if (type_ == NULL) {
|
||
|
type_ = new ::opencv_onnx::TypeProto;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.type)
|
||
|
return type_;
|
||
|
}
|
||
|
inline void ValueInfoProto::set_allocated_type(::opencv_onnx::TypeProto* type) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete type_;
|
||
|
}
|
||
|
if (type) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
type = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, type, submessage_arena);
|
||
|
}
|
||
|
set_has_type();
|
||
|
} else {
|
||
|
clear_has_type();
|
||
|
}
|
||
|
type_ = type;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.type)
|
||
|
}
|
||
|
|
||
|
// optional string doc_string = 3;
|
||
|
inline bool ValueInfoProto::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void ValueInfoProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void ValueInfoProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& ValueInfoProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void ValueInfoProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ValueInfoProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ValueInfoProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
}
|
||
|
inline void ValueInfoProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* ValueInfoProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ValueInfoProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ValueInfoProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ValueInfoProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// NodeProto
|
||
|
|
||
|
// repeated string input = 1;
|
||
|
inline int NodeProto::input_size() const {
|
||
|
return input_.size();
|
||
|
}
|
||
|
inline void NodeProto::clear_input() {
|
||
|
input_.Clear();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::input(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.input)
|
||
|
return input_.Get(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) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
|
||
|
input_.Mutable(index)->assign(value);
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_input(int index, ::std::string&& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.input)
|
||
|
input_.Mutable(index)->assign(std::move(value));
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_input(int index, const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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::add_input() {
|
||
|
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.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)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::add_input(::std::string&& value) {
|
||
|
input_.Add(std::move(value));
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.input)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::add_input(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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 ::google::protobuf::RepeatedPtrField< ::std::string>&
|
||
|
NodeProto::input() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.input)
|
||
|
return input_;
|
||
|
}
|
||
|
inline ::google::protobuf::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::output_size() const {
|
||
|
return output_.size();
|
||
|
}
|
||
|
inline void NodeProto::clear_output() {
|
||
|
output_.Clear();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::output(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.output)
|
||
|
return output_.Get(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) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
|
||
|
output_.Mutable(index)->assign(value);
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_output(int index, ::std::string&& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.output)
|
||
|
output_.Mutable(index)->assign(std::move(value));
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_output(int index, const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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::add_output() {
|
||
|
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.NodeProto.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)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::add_output(::std::string&& value) {
|
||
|
output_.Add(std::move(value));
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.output)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::add_output(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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 ::google::protobuf::RepeatedPtrField< ::std::string>&
|
||
|
NodeProto::output() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.NodeProto.output)
|
||
|
return output_;
|
||
|
}
|
||
|
inline ::google::protobuf::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::has_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void NodeProto::set_has_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void NodeProto::clear_has_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void NodeProto::clear_name() {
|
||
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_name();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.name)
|
||
|
return name_.GetNoArena();
|
||
|
}
|
||
|
inline void NodeProto::set_name(const ::std::string& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_name(::std::string&& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.name)
|
||
|
}
|
||
|
inline void NodeProto::set_name(const char* value, size_t size) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.name)
|
||
|
}
|
||
|
inline ::std::string* NodeProto::mutable_name() {
|
||
|
set_has_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.name)
|
||
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* NodeProto::release_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.name)
|
||
|
clear_has_name();
|
||
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void NodeProto::set_allocated_name(::std::string* name) {
|
||
|
if (name != NULL) {
|
||
|
set_has_name();
|
||
|
} else {
|
||
|
clear_has_name();
|
||
|
}
|
||
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.name)
|
||
|
}
|
||
|
|
||
|
// optional string op_type = 4;
|
||
|
inline bool NodeProto::has_op_type() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void NodeProto::set_has_op_type() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void NodeProto::clear_has_op_type() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void NodeProto::clear_op_type() {
|
||
|
op_type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_op_type();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::op_type() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.op_type)
|
||
|
return op_type_.GetNoArena();
|
||
|
}
|
||
|
inline void NodeProto::set_op_type(const ::std::string& value) {
|
||
|
set_has_op_type();
|
||
|
op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.op_type)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_op_type(::std::string&& value) {
|
||
|
set_has_op_type();
|
||
|
op_type_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.op_type)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_op_type(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_op_type();
|
||
|
op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.op_type)
|
||
|
}
|
||
|
inline void NodeProto::set_op_type(const char* value, size_t size) {
|
||
|
set_has_op_type();
|
||
|
op_type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.op_type)
|
||
|
}
|
||
|
inline ::std::string* NodeProto::mutable_op_type() {
|
||
|
set_has_op_type();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.op_type)
|
||
|
return op_type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* NodeProto::release_op_type() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.op_type)
|
||
|
clear_has_op_type();
|
||
|
return op_type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void NodeProto::set_allocated_op_type(::std::string* op_type) {
|
||
|
if (op_type != NULL) {
|
||
|
set_has_op_type();
|
||
|
} else {
|
||
|
clear_has_op_type();
|
||
|
}
|
||
|
op_type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), op_type);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.op_type)
|
||
|
}
|
||
|
|
||
|
// optional string domain = 7;
|
||
|
inline bool NodeProto::has_domain() const {
|
||
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
||
|
}
|
||
|
inline void NodeProto::set_has_domain() {
|
||
|
_has_bits_[0] |= 0x00000008u;
|
||
|
}
|
||
|
inline void NodeProto::clear_has_domain() {
|
||
|
_has_bits_[0] &= ~0x00000008u;
|
||
|
}
|
||
|
inline void NodeProto::clear_domain() {
|
||
|
domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::domain() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.domain)
|
||
|
return domain_.GetNoArena();
|
||
|
}
|
||
|
inline void NodeProto::set_domain(const ::std::string& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.domain)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_domain(::std::string&& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.domain)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_domain(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.domain)
|
||
|
}
|
||
|
inline void NodeProto::set_domain(const char* value, size_t size) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.domain)
|
||
|
}
|
||
|
inline ::std::string* NodeProto::mutable_domain() {
|
||
|
set_has_domain();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.domain)
|
||
|
return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* NodeProto::release_domain() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.domain)
|
||
|
clear_has_domain();
|
||
|
return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void NodeProto::set_allocated_domain(::std::string* domain) {
|
||
|
if (domain != NULL) {
|
||
|
set_has_domain();
|
||
|
} else {
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.domain)
|
||
|
}
|
||
|
|
||
|
// repeated .opencv_onnx.AttributeProto attribute = 5;
|
||
|
inline int NodeProto::attribute_size() const {
|
||
|
return attribute_.size();
|
||
|
}
|
||
|
inline void NodeProto::clear_attribute() {
|
||
|
attribute_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::AttributeProto& NodeProto::attribute(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.attribute)
|
||
|
return attribute_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::AttributeProto* NodeProto::mutable_attribute(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.attribute)
|
||
|
return attribute_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::AttributeProto* NodeProto::add_attribute() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.NodeProto.attribute)
|
||
|
return attribute_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::AttributeProto >*
|
||
|
NodeProto::mutable_attribute() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.NodeProto.attribute)
|
||
|
return &attribute_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
||
|
}
|
||
|
inline void NodeProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000004u;
|
||
|
}
|
||
|
inline void NodeProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000004u;
|
||
|
}
|
||
|
inline void NodeProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& NodeProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.NodeProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void NodeProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.NodeProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void NodeProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.NodeProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void NodeProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.NodeProto.doc_string)
|
||
|
}
|
||
|
inline void NodeProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.NodeProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* NodeProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.NodeProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* NodeProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.NodeProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void NodeProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.NodeProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// ModelProto
|
||
|
|
||
|
// optional int64 ir_version = 1;
|
||
|
inline bool ModelProto::has_ir_version() const {
|
||
|
return (_has_bits_[0] & 0x00000020u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_ir_version() {
|
||
|
_has_bits_[0] |= 0x00000020u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_ir_version() {
|
||
|
_has_bits_[0] &= ~0x00000020u;
|
||
|
}
|
||
|
inline void ModelProto::clear_ir_version() {
|
||
|
ir_version_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_ir_version();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 ModelProto::ir_version() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.ir_version)
|
||
|
return ir_version_;
|
||
|
}
|
||
|
inline void ModelProto::set_ir_version(::google::protobuf::int64 value) {
|
||
|
set_has_ir_version();
|
||
|
ir_version_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.ir_version)
|
||
|
}
|
||
|
|
||
|
// repeated .opencv_onnx.OperatorSetIdProto opset_import = 8;
|
||
|
inline int ModelProto::opset_import_size() const {
|
||
|
return opset_import_.size();
|
||
|
}
|
||
|
inline void ModelProto::clear_opset_import() {
|
||
|
opset_import_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::OperatorSetIdProto& ModelProto::opset_import(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.opset_import)
|
||
|
return opset_import_.Get(index);
|
||
|
}
|
||
|
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 ::opencv_onnx::OperatorSetIdProto* ModelProto::add_opset_import() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.opset_import)
|
||
|
return opset_import_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::OperatorSetIdProto >*
|
||
|
ModelProto::mutable_opset_import() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.opset_import)
|
||
|
return &opset_import_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::has_producer_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_producer_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_producer_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void ModelProto::clear_producer_name() {
|
||
|
producer_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_producer_name();
|
||
|
}
|
||
|
inline const ::std::string& ModelProto::producer_name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_name)
|
||
|
return producer_name_.GetNoArena();
|
||
|
}
|
||
|
inline void ModelProto::set_producer_name(const ::std::string& value) {
|
||
|
set_has_producer_name();
|
||
|
producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ModelProto::set_producer_name(::std::string&& value) {
|
||
|
set_has_producer_name();
|
||
|
producer_name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.producer_name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ModelProto::set_producer_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_producer_name();
|
||
|
producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.producer_name)
|
||
|
}
|
||
|
inline void ModelProto::set_producer_name(const char* value, size_t size) {
|
||
|
set_has_producer_name();
|
||
|
producer_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.producer_name)
|
||
|
}
|
||
|
inline ::std::string* ModelProto::mutable_producer_name() {
|
||
|
set_has_producer_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_name)
|
||
|
return producer_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ModelProto::release_producer_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_name)
|
||
|
clear_has_producer_name();
|
||
|
return producer_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ModelProto::set_allocated_producer_name(::std::string* producer_name) {
|
||
|
if (producer_name != NULL) {
|
||
|
set_has_producer_name();
|
||
|
} else {
|
||
|
clear_has_producer_name();
|
||
|
}
|
||
|
producer_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), producer_name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_name)
|
||
|
}
|
||
|
|
||
|
// optional string producer_version = 3;
|
||
|
inline bool ModelProto::has_producer_version() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_producer_version() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_producer_version() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void ModelProto::clear_producer_version() {
|
||
|
producer_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_producer_version();
|
||
|
}
|
||
|
inline const ::std::string& ModelProto::producer_version() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.producer_version)
|
||
|
return producer_version_.GetNoArena();
|
||
|
}
|
||
|
inline void ModelProto::set_producer_version(const ::std::string& value) {
|
||
|
set_has_producer_version();
|
||
|
producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.producer_version)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ModelProto::set_producer_version(::std::string&& value) {
|
||
|
set_has_producer_version();
|
||
|
producer_version_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.producer_version)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ModelProto::set_producer_version(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_producer_version();
|
||
|
producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.producer_version)
|
||
|
}
|
||
|
inline void ModelProto::set_producer_version(const char* value, size_t size) {
|
||
|
set_has_producer_version();
|
||
|
producer_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.producer_version)
|
||
|
}
|
||
|
inline ::std::string* ModelProto::mutable_producer_version() {
|
||
|
set_has_producer_version();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.producer_version)
|
||
|
return producer_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ModelProto::release_producer_version() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.producer_version)
|
||
|
clear_has_producer_version();
|
||
|
return producer_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ModelProto::set_allocated_producer_version(::std::string* producer_version) {
|
||
|
if (producer_version != NULL) {
|
||
|
set_has_producer_version();
|
||
|
} else {
|
||
|
clear_has_producer_version();
|
||
|
}
|
||
|
producer_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), producer_version);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.producer_version)
|
||
|
}
|
||
|
|
||
|
// optional string domain = 4;
|
||
|
inline bool ModelProto::has_domain() const {
|
||
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_domain() {
|
||
|
_has_bits_[0] |= 0x00000004u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_domain() {
|
||
|
_has_bits_[0] &= ~0x00000004u;
|
||
|
}
|
||
|
inline void ModelProto::clear_domain() {
|
||
|
domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
inline const ::std::string& ModelProto::domain() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.domain)
|
||
|
return domain_.GetNoArena();
|
||
|
}
|
||
|
inline void ModelProto::set_domain(const ::std::string& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.domain)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ModelProto::set_domain(::std::string&& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.domain)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ModelProto::set_domain(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.domain)
|
||
|
}
|
||
|
inline void ModelProto::set_domain(const char* value, size_t size) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.domain)
|
||
|
}
|
||
|
inline ::std::string* ModelProto::mutable_domain() {
|
||
|
set_has_domain();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.domain)
|
||
|
return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ModelProto::release_domain() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.domain)
|
||
|
clear_has_domain();
|
||
|
return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ModelProto::set_allocated_domain(::std::string* domain) {
|
||
|
if (domain != NULL) {
|
||
|
set_has_domain();
|
||
|
} else {
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.domain)
|
||
|
}
|
||
|
|
||
|
// optional int64 model_version = 5;
|
||
|
inline bool ModelProto::has_model_version() const {
|
||
|
return (_has_bits_[0] & 0x00000040u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_model_version() {
|
||
|
_has_bits_[0] |= 0x00000040u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_model_version() {
|
||
|
_has_bits_[0] &= ~0x00000040u;
|
||
|
}
|
||
|
inline void ModelProto::clear_model_version() {
|
||
|
model_version_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_model_version();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 ModelProto::model_version() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.model_version)
|
||
|
return model_version_;
|
||
|
}
|
||
|
inline void ModelProto::set_model_version(::google::protobuf::int64 value) {
|
||
|
set_has_model_version();
|
||
|
model_version_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.model_version)
|
||
|
}
|
||
|
|
||
|
// optional string doc_string = 6;
|
||
|
inline bool ModelProto::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000008u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000008u;
|
||
|
}
|
||
|
inline void ModelProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& ModelProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void ModelProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.ModelProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void ModelProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.ModelProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void ModelProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.ModelProto.doc_string)
|
||
|
}
|
||
|
inline void ModelProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.ModelProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* ModelProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* ModelProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void ModelProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.GraphProto graph = 7;
|
||
|
inline bool ModelProto::has_graph() const {
|
||
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
||
|
}
|
||
|
inline void ModelProto::set_has_graph() {
|
||
|
_has_bits_[0] |= 0x00000010u;
|
||
|
}
|
||
|
inline void ModelProto::clear_has_graph() {
|
||
|
_has_bits_[0] &= ~0x00000010u;
|
||
|
}
|
||
|
inline void ModelProto::clear_graph() {
|
||
|
if (graph_ != NULL) graph_->Clear();
|
||
|
clear_has_graph();
|
||
|
}
|
||
|
inline const ::opencv_onnx::GraphProto& ModelProto::graph() const {
|
||
|
const ::opencv_onnx::GraphProto* p = graph_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.graph)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::GraphProto*>(
|
||
|
&::opencv_onnx::_GraphProto_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* ModelProto::release_graph() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.ModelProto.graph)
|
||
|
clear_has_graph();
|
||
|
::opencv_onnx::GraphProto* temp = graph_;
|
||
|
graph_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::GraphProto* ModelProto::mutable_graph() {
|
||
|
set_has_graph();
|
||
|
if (graph_ == NULL) {
|
||
|
graph_ = new ::opencv_onnx::GraphProto;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.ModelProto.graph)
|
||
|
return graph_;
|
||
|
}
|
||
|
inline void ModelProto::set_allocated_graph(::opencv_onnx::GraphProto* graph) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete graph_;
|
||
|
}
|
||
|
if (graph) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
graph = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, graph, submessage_arena);
|
||
|
}
|
||
|
set_has_graph();
|
||
|
} else {
|
||
|
clear_has_graph();
|
||
|
}
|
||
|
graph_ = graph;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.ModelProto.graph)
|
||
|
}
|
||
|
|
||
|
// repeated .opencv_onnx.StringStringEntryProto metadata_props = 14;
|
||
|
inline int ModelProto::metadata_props_size() const {
|
||
|
return metadata_props_.size();
|
||
|
}
|
||
|
inline void ModelProto::clear_metadata_props() {
|
||
|
metadata_props_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::StringStringEntryProto& ModelProto::metadata_props(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.ModelProto.metadata_props)
|
||
|
return metadata_props_.Get(index);
|
||
|
}
|
||
|
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 ::opencv_onnx::StringStringEntryProto* ModelProto::add_metadata_props() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.ModelProto.metadata_props)
|
||
|
return metadata_props_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >*
|
||
|
ModelProto::mutable_metadata_props() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.ModelProto.metadata_props)
|
||
|
return &metadata_props_;
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::StringStringEntryProto >&
|
||
|
ModelProto::metadata_props() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.ModelProto.metadata_props)
|
||
|
return metadata_props_;
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// StringStringEntryProto
|
||
|
|
||
|
// optional string key = 1;
|
||
|
inline bool StringStringEntryProto::has_key() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_has_key() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void StringStringEntryProto::clear_has_key() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void StringStringEntryProto::clear_key() {
|
||
|
key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_key();
|
||
|
}
|
||
|
inline const ::std::string& StringStringEntryProto::key() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.key)
|
||
|
return key_.GetNoArena();
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_key(const ::std::string& value) {
|
||
|
set_has_key();
|
||
|
key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.key)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void StringStringEntryProto::set_key(::std::string&& value) {
|
||
|
set_has_key();
|
||
|
key_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.key)
|
||
|
}
|
||
|
#endif
|
||
|
inline void StringStringEntryProto::set_key(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_key();
|
||
|
key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.key)
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_key(const char* value, size_t size) {
|
||
|
set_has_key();
|
||
|
key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.key)
|
||
|
}
|
||
|
inline ::std::string* StringStringEntryProto::mutable_key() {
|
||
|
set_has_key();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.key)
|
||
|
return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* StringStringEntryProto::release_key() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.key)
|
||
|
clear_has_key();
|
||
|
return key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_allocated_key(::std::string* key) {
|
||
|
if (key != NULL) {
|
||
|
set_has_key();
|
||
|
} else {
|
||
|
clear_has_key();
|
||
|
}
|
||
|
key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.key)
|
||
|
}
|
||
|
|
||
|
// optional string value = 2;
|
||
|
inline bool StringStringEntryProto::has_value() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_has_value() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void StringStringEntryProto::clear_has_value() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void StringStringEntryProto::clear_value() {
|
||
|
value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_value();
|
||
|
}
|
||
|
inline const ::std::string& StringStringEntryProto::value() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.StringStringEntryProto.value)
|
||
|
return value_.GetNoArena();
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_value(const ::std::string& value) {
|
||
|
set_has_value();
|
||
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.StringStringEntryProto.value)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void StringStringEntryProto::set_value(::std::string&& value) {
|
||
|
set_has_value();
|
||
|
value_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.StringStringEntryProto.value)
|
||
|
}
|
||
|
#endif
|
||
|
inline void StringStringEntryProto::set_value(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_value();
|
||
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.StringStringEntryProto.value)
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_value(const char* value, size_t size) {
|
||
|
set_has_value();
|
||
|
value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.StringStringEntryProto.value)
|
||
|
}
|
||
|
inline ::std::string* StringStringEntryProto::mutable_value() {
|
||
|
set_has_value();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.StringStringEntryProto.value)
|
||
|
return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* StringStringEntryProto::release_value() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.StringStringEntryProto.value)
|
||
|
clear_has_value();
|
||
|
return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void StringStringEntryProto::set_allocated_value(::std::string* value) {
|
||
|
if (value != NULL) {
|
||
|
set_has_value();
|
||
|
} else {
|
||
|
clear_has_value();
|
||
|
}
|
||
|
value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.StringStringEntryProto.value)
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// GraphProto
|
||
|
|
||
|
// repeated .opencv_onnx.NodeProto node = 1;
|
||
|
inline int GraphProto::node_size() const {
|
||
|
return node_.size();
|
||
|
}
|
||
|
inline void GraphProto::clear_node() {
|
||
|
node_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::NodeProto& GraphProto::node(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.node)
|
||
|
return node_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::NodeProto* GraphProto::mutable_node(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.node)
|
||
|
return node_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::NodeProto* GraphProto::add_node() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.node)
|
||
|
return node_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::NodeProto >*
|
||
|
GraphProto::mutable_node() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.node)
|
||
|
return &node_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::has_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void GraphProto::set_has_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void GraphProto::clear_has_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void GraphProto::clear_name() {
|
||
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_name();
|
||
|
}
|
||
|
inline const ::std::string& GraphProto::name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.name)
|
||
|
return name_.GetNoArena();
|
||
|
}
|
||
|
inline void GraphProto::set_name(const ::std::string& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void GraphProto::set_name(::std::string&& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void GraphProto::set_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.name)
|
||
|
}
|
||
|
inline void GraphProto::set_name(const char* value, size_t size) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.name)
|
||
|
}
|
||
|
inline ::std::string* GraphProto::mutable_name() {
|
||
|
set_has_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.name)
|
||
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* GraphProto::release_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.name)
|
||
|
clear_has_name();
|
||
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void GraphProto::set_allocated_name(::std::string* name) {
|
||
|
if (name != NULL) {
|
||
|
set_has_name();
|
||
|
} else {
|
||
|
clear_has_name();
|
||
|
}
|
||
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.name)
|
||
|
}
|
||
|
|
||
|
// repeated .opencv_onnx.TensorProto initializer = 5;
|
||
|
inline int GraphProto::initializer_size() const {
|
||
|
return initializer_.size();
|
||
|
}
|
||
|
inline void GraphProto::clear_initializer() {
|
||
|
initializer_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorProto& GraphProto::initializer(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.initializer)
|
||
|
return initializer_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* GraphProto::mutable_initializer(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.initializer)
|
||
|
return initializer_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto* GraphProto::add_initializer() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.initializer)
|
||
|
return initializer_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >*
|
||
|
GraphProto::mutable_initializer() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.initializer)
|
||
|
return &initializer_;
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorProto >&
|
||
|
GraphProto::initializer() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.initializer)
|
||
|
return initializer_;
|
||
|
}
|
||
|
|
||
|
// optional string doc_string = 10;
|
||
|
inline bool GraphProto::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void GraphProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void GraphProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void GraphProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& GraphProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void GraphProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.GraphProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void GraphProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.GraphProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void GraphProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.GraphProto.doc_string)
|
||
|
}
|
||
|
inline void GraphProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.GraphProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* GraphProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* GraphProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.GraphProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void GraphProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.GraphProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// repeated .opencv_onnx.ValueInfoProto input = 11;
|
||
|
inline int GraphProto::input_size() const {
|
||
|
return input_.size();
|
||
|
}
|
||
|
inline void GraphProto::clear_input() {
|
||
|
input_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::ValueInfoProto& GraphProto::input(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.input)
|
||
|
return input_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_input(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.input)
|
||
|
return input_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_input() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.input)
|
||
|
return input_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
GraphProto::mutable_input() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.input)
|
||
|
return &input_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::output_size() const {
|
||
|
return output_.size();
|
||
|
}
|
||
|
inline void GraphProto::clear_output() {
|
||
|
output_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::ValueInfoProto& GraphProto::output(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.output)
|
||
|
return output_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::ValueInfoProto* GraphProto::mutable_output(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.GraphProto.output)
|
||
|
return output_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::ValueInfoProto* GraphProto::add_output() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.output)
|
||
|
return output_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
GraphProto::mutable_output() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.output)
|
||
|
return &output_;
|
||
|
}
|
||
|
inline const ::google::protobuf::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::value_info_size() const {
|
||
|
return value_info_.size();
|
||
|
}
|
||
|
inline void GraphProto::clear_value_info() {
|
||
|
value_info_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::ValueInfoProto& GraphProto::value_info(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.GraphProto.value_info)
|
||
|
return value_info_.Get(index);
|
||
|
}
|
||
|
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 ::opencv_onnx::ValueInfoProto* GraphProto::add_value_info() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.GraphProto.value_info)
|
||
|
return value_info_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >*
|
||
|
GraphProto::mutable_value_info() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.GraphProto.value_info)
|
||
|
return &value_info_;
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::ValueInfoProto >&
|
||
|
GraphProto::value_info() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.GraphProto.value_info)
|
||
|
return value_info_;
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// TensorProto_Segment
|
||
|
|
||
|
// optional int64 begin = 1;
|
||
|
inline bool TensorProto_Segment::has_begin() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void TensorProto_Segment::set_has_begin() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void TensorProto_Segment::clear_has_begin() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void TensorProto_Segment::clear_begin() {
|
||
|
begin_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_begin();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 TensorProto_Segment::begin() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.begin)
|
||
|
return begin_;
|
||
|
}
|
||
|
inline void TensorProto_Segment::set_begin(::google::protobuf::int64 value) {
|
||
|
set_has_begin();
|
||
|
begin_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.begin)
|
||
|
}
|
||
|
|
||
|
// optional int64 end = 2;
|
||
|
inline bool TensorProto_Segment::has_end() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void TensorProto_Segment::set_has_end() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void TensorProto_Segment::clear_has_end() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void TensorProto_Segment::clear_end() {
|
||
|
end_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_end();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 TensorProto_Segment::end() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.Segment.end)
|
||
|
return end_;
|
||
|
}
|
||
|
inline void TensorProto_Segment::set_end(::google::protobuf::int64 value) {
|
||
|
set_has_end();
|
||
|
end_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.Segment.end)
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// TensorProto
|
||
|
|
||
|
// repeated int64 dims = 1;
|
||
|
inline int TensorProto::dims_size() const {
|
||
|
return dims_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_dims() {
|
||
|
dims_.Clear();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 TensorProto::dims(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.dims)
|
||
|
return dims_.Get(index);
|
||
|
}
|
||
|
inline void TensorProto::set_dims(int index, ::google::protobuf::int64 value) {
|
||
|
dims_.Set(index, value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.dims)
|
||
|
}
|
||
|
inline void TensorProto::add_dims(::google::protobuf::int64 value) {
|
||
|
dims_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.dims)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
TensorProto::dims() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.dims)
|
||
|
return dims_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
TensorProto::mutable_dims() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.dims)
|
||
|
return &dims_;
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.DataType data_type = 2;
|
||
|
inline bool TensorProto::has_data_type() const {
|
||
|
return (_has_bits_[0] & 0x00000010u) != 0;
|
||
|
}
|
||
|
inline void TensorProto::set_has_data_type() {
|
||
|
_has_bits_[0] |= 0x00000010u;
|
||
|
}
|
||
|
inline void TensorProto::clear_has_data_type() {
|
||
|
_has_bits_[0] &= ~0x00000010u;
|
||
|
}
|
||
|
inline void TensorProto::clear_data_type() {
|
||
|
data_type_ = 0;
|
||
|
clear_has_data_type();
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto_DataType TensorProto::data_type() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.data_type)
|
||
|
return static_cast< ::opencv_onnx::TensorProto_DataType >(data_type_);
|
||
|
}
|
||
|
inline void TensorProto::set_data_type(::opencv_onnx::TensorProto_DataType value) {
|
||
|
assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
|
||
|
set_has_data_type();
|
||
|
data_type_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.data_type)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.Segment segment = 3;
|
||
|
inline bool TensorProto::has_segment() const {
|
||
|
return (_has_bits_[0] & 0x00000008u) != 0;
|
||
|
}
|
||
|
inline void TensorProto::set_has_segment() {
|
||
|
_has_bits_[0] |= 0x00000008u;
|
||
|
}
|
||
|
inline void TensorProto::clear_has_segment() {
|
||
|
_has_bits_[0] &= ~0x00000008u;
|
||
|
}
|
||
|
inline void TensorProto::clear_segment() {
|
||
|
if (segment_ != NULL) segment_->Clear();
|
||
|
clear_has_segment();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorProto_Segment& TensorProto::segment() const {
|
||
|
const ::opencv_onnx::TensorProto_Segment* p = segment_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.segment)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorProto_Segment*>(
|
||
|
&::opencv_onnx::_TensorProto_Segment_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto_Segment* TensorProto::release_segment() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.segment)
|
||
|
clear_has_segment();
|
||
|
::opencv_onnx::TensorProto_Segment* temp = segment_;
|
||
|
segment_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto_Segment* TensorProto::mutable_segment() {
|
||
|
set_has_segment();
|
||
|
if (segment_ == NULL) {
|
||
|
segment_ = new ::opencv_onnx::TensorProto_Segment;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.segment)
|
||
|
return segment_;
|
||
|
}
|
||
|
inline void TensorProto::set_allocated_segment(::opencv_onnx::TensorProto_Segment* segment) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete segment_;
|
||
|
}
|
||
|
if (segment) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
segment = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, segment, submessage_arena);
|
||
|
}
|
||
|
set_has_segment();
|
||
|
} else {
|
||
|
clear_has_segment();
|
||
|
}
|
||
|
segment_ = segment;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.segment)
|
||
|
}
|
||
|
|
||
|
// repeated float float_data = 4 [packed = true];
|
||
|
inline int TensorProto::float_data_size() const {
|
||
|
return float_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_float_data() {
|
||
|
float_data_.Clear();
|
||
|
}
|
||
|
inline float TensorProto::float_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.float_data)
|
||
|
return float_data_.Get(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::add_float_data(float value) {
|
||
|
float_data_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.float_data)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< float >&
|
||
|
TensorProto::float_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.float_data)
|
||
|
return float_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< float >*
|
||
|
TensorProto::mutable_float_data() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.float_data)
|
||
|
return &float_data_;
|
||
|
}
|
||
|
|
||
|
// repeated int32 int32_data = 5 [packed = true];
|
||
|
inline int TensorProto::int32_data_size() const {
|
||
|
return int32_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_int32_data() {
|
||
|
int32_data_.Clear();
|
||
|
}
|
||
|
inline ::google::protobuf::int32 TensorProto::int32_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int32_data)
|
||
|
return int32_data_.Get(index);
|
||
|
}
|
||
|
inline void TensorProto::set_int32_data(int index, ::google::protobuf::int32 value) {
|
||
|
int32_data_.Set(index, value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int32_data)
|
||
|
}
|
||
|
inline void TensorProto::add_int32_data(::google::protobuf::int32 value) {
|
||
|
int32_data_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int32_data)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
|
||
|
TensorProto::int32_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int32_data)
|
||
|
return int32_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
|
||
|
TensorProto::mutable_int32_data() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int32_data)
|
||
|
return &int32_data_;
|
||
|
}
|
||
|
|
||
|
// repeated bytes string_data = 6;
|
||
|
inline int TensorProto::string_data_size() const {
|
||
|
return string_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_string_data() {
|
||
|
string_data_.Clear();
|
||
|
}
|
||
|
inline const ::std::string& TensorProto::string_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.string_data)
|
||
|
return string_data_.Get(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) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
|
||
|
string_data_.Mutable(index)->assign(value);
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorProto::set_string_data(int index, ::std::string&& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.string_data)
|
||
|
string_data_.Mutable(index)->assign(std::move(value));
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorProto::set_string_data(int index, const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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::add_string_data() {
|
||
|
// @@protoc_insertion_point(field_add_mutable:opencv_onnx.TensorProto.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)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
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)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorProto::add_string_data(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
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 ::google::protobuf::RepeatedPtrField< ::std::string>&
|
||
|
TensorProto::string_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.string_data)
|
||
|
return string_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::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::int64_data_size() const {
|
||
|
return int64_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_int64_data() {
|
||
|
int64_data_.Clear();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 TensorProto::int64_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.int64_data)
|
||
|
return int64_data_.Get(index);
|
||
|
}
|
||
|
inline void TensorProto::set_int64_data(int index, ::google::protobuf::int64 value) {
|
||
|
int64_data_.Set(index, value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.int64_data)
|
||
|
}
|
||
|
inline void TensorProto::add_int64_data(::google::protobuf::int64 value) {
|
||
|
int64_data_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.int64_data)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
|
||
|
TensorProto::int64_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.int64_data)
|
||
|
return int64_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
|
||
|
TensorProto::mutable_int64_data() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.int64_data)
|
||
|
return &int64_data_;
|
||
|
}
|
||
|
|
||
|
// optional string name = 8;
|
||
|
inline bool TensorProto::has_name() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void TensorProto::set_has_name() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void TensorProto::clear_has_name() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void TensorProto::clear_name() {
|
||
|
name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_name();
|
||
|
}
|
||
|
inline const ::std::string& TensorProto::name() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.name)
|
||
|
return name_.GetNoArena();
|
||
|
}
|
||
|
inline void TensorProto::set_name(const ::std::string& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.name)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorProto::set_name(::std::string&& value) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.name)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorProto::set_name(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.name)
|
||
|
}
|
||
|
inline void TensorProto::set_name(const char* value, size_t size) {
|
||
|
set_has_name();
|
||
|
name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.name)
|
||
|
}
|
||
|
inline ::std::string* TensorProto::mutable_name() {
|
||
|
set_has_name();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.name)
|
||
|
return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TensorProto::release_name() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.name)
|
||
|
clear_has_name();
|
||
|
return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void TensorProto::set_allocated_name(::std::string* name) {
|
||
|
if (name != NULL) {
|
||
|
set_has_name();
|
||
|
} else {
|
||
|
clear_has_name();
|
||
|
}
|
||
|
name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.name)
|
||
|
}
|
||
|
|
||
|
// optional string doc_string = 12;
|
||
|
inline bool TensorProto::has_doc_string() const {
|
||
|
return (_has_bits_[0] & 0x00000004u) != 0;
|
||
|
}
|
||
|
inline void TensorProto::set_has_doc_string() {
|
||
|
_has_bits_[0] |= 0x00000004u;
|
||
|
}
|
||
|
inline void TensorProto::clear_has_doc_string() {
|
||
|
_has_bits_[0] &= ~0x00000004u;
|
||
|
}
|
||
|
inline void TensorProto::clear_doc_string() {
|
||
|
doc_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
inline const ::std::string& TensorProto::doc_string() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.doc_string)
|
||
|
return doc_string_.GetNoArena();
|
||
|
}
|
||
|
inline void TensorProto::set_doc_string(const ::std::string& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.doc_string)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorProto::set_doc_string(::std::string&& value) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.doc_string)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorProto::set_doc_string(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.doc_string)
|
||
|
}
|
||
|
inline void TensorProto::set_doc_string(const char* value, size_t size) {
|
||
|
set_has_doc_string();
|
||
|
doc_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.doc_string)
|
||
|
}
|
||
|
inline ::std::string* TensorProto::mutable_doc_string() {
|
||
|
set_has_doc_string();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.doc_string)
|
||
|
return doc_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TensorProto::release_doc_string() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.doc_string)
|
||
|
clear_has_doc_string();
|
||
|
return doc_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void TensorProto::set_allocated_doc_string(::std::string* doc_string) {
|
||
|
if (doc_string != NULL) {
|
||
|
set_has_doc_string();
|
||
|
} else {
|
||
|
clear_has_doc_string();
|
||
|
}
|
||
|
doc_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), doc_string);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.doc_string)
|
||
|
}
|
||
|
|
||
|
// optional bytes raw_data = 9;
|
||
|
inline bool TensorProto::has_raw_data() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void TensorProto::set_has_raw_data() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void TensorProto::clear_has_raw_data() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void TensorProto::clear_raw_data() {
|
||
|
raw_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_raw_data();
|
||
|
}
|
||
|
inline const ::std::string& TensorProto::raw_data() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.raw_data)
|
||
|
return raw_data_.GetNoArena();
|
||
|
}
|
||
|
inline void TensorProto::set_raw_data(const ::std::string& value) {
|
||
|
set_has_raw_data();
|
||
|
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.raw_data)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorProto::set_raw_data(::std::string&& value) {
|
||
|
set_has_raw_data();
|
||
|
raw_data_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorProto.raw_data)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorProto::set_raw_data(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_raw_data();
|
||
|
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorProto.raw_data)
|
||
|
}
|
||
|
inline void TensorProto::set_raw_data(const void* value, size_t size) {
|
||
|
set_has_raw_data();
|
||
|
raw_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorProto.raw_data)
|
||
|
}
|
||
|
inline ::std::string* TensorProto::mutable_raw_data() {
|
||
|
set_has_raw_data();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorProto.raw_data)
|
||
|
return raw_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TensorProto::release_raw_data() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorProto.raw_data)
|
||
|
clear_has_raw_data();
|
||
|
return raw_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void TensorProto::set_allocated_raw_data(::std::string* raw_data) {
|
||
|
if (raw_data != NULL) {
|
||
|
set_has_raw_data();
|
||
|
} else {
|
||
|
clear_has_raw_data();
|
||
|
}
|
||
|
raw_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), raw_data);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorProto.raw_data)
|
||
|
}
|
||
|
|
||
|
// repeated double double_data = 10 [packed = true];
|
||
|
inline int TensorProto::double_data_size() const {
|
||
|
return double_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_double_data() {
|
||
|
double_data_.Clear();
|
||
|
}
|
||
|
inline double TensorProto::double_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.double_data)
|
||
|
return double_data_.Get(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::add_double_data(double value) {
|
||
|
double_data_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.double_data)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< double >&
|
||
|
TensorProto::double_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.double_data)
|
||
|
return double_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< double >*
|
||
|
TensorProto::mutable_double_data() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.double_data)
|
||
|
return &double_data_;
|
||
|
}
|
||
|
|
||
|
// repeated uint64 uint64_data = 11 [packed = true];
|
||
|
inline int TensorProto::uint64_data_size() const {
|
||
|
return uint64_data_.size();
|
||
|
}
|
||
|
inline void TensorProto::clear_uint64_data() {
|
||
|
uint64_data_.Clear();
|
||
|
}
|
||
|
inline ::google::protobuf::uint64 TensorProto::uint64_data(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorProto.uint64_data)
|
||
|
return uint64_data_.Get(index);
|
||
|
}
|
||
|
inline void TensorProto::set_uint64_data(int index, ::google::protobuf::uint64 value) {
|
||
|
uint64_data_.Set(index, value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorProto.uint64_data)
|
||
|
}
|
||
|
inline void TensorProto::add_uint64_data(::google::protobuf::uint64 value) {
|
||
|
uint64_data_.Add(value);
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorProto.uint64_data)
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
|
||
|
TensorProto::uint64_data() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorProto.uint64_data)
|
||
|
return uint64_data_;
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
|
||
|
TensorProto::mutable_uint64_data() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorProto.uint64_data)
|
||
|
return &uint64_data_;
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// TensorShapeProto_Dimension
|
||
|
|
||
|
// optional int64 dim_value = 1;
|
||
|
inline bool TensorShapeProto_Dimension::has_dim_value() const {
|
||
|
return value_case() == kDimValue;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_has_dim_value() {
|
||
|
_oneof_case_[0] = kDimValue;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::clear_dim_value() {
|
||
|
if (has_dim_value()) {
|
||
|
value_.dim_value_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_value();
|
||
|
}
|
||
|
}
|
||
|
inline ::google::protobuf::int64 TensorShapeProto_Dimension::dim_value() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_value)
|
||
|
if (has_dim_value()) {
|
||
|
return value_.dim_value_;
|
||
|
}
|
||
|
return GOOGLE_LONGLONG(0);
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_dim_value(::google::protobuf::int64 value) {
|
||
|
if (!has_dim_value()) {
|
||
|
clear_value();
|
||
|
set_has_dim_value();
|
||
|
}
|
||
|
value_.dim_value_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_value)
|
||
|
}
|
||
|
|
||
|
// optional string dim_param = 2;
|
||
|
inline bool TensorShapeProto_Dimension::has_dim_param() const {
|
||
|
return value_case() == kDimParam;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_has_dim_param() {
|
||
|
_oneof_case_[0] = kDimParam;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::clear_dim_param() {
|
||
|
if (has_dim_param()) {
|
||
|
value_.dim_param_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_value();
|
||
|
}
|
||
|
}
|
||
|
inline const ::std::string& TensorShapeProto_Dimension::dim_param() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
if (has_dim_param()) {
|
||
|
return value_.dim_param_.GetNoArena();
|
||
|
}
|
||
|
return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_dim_param(const ::std::string& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
if (!has_dim_param()) {
|
||
|
clear_value();
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorShapeProto_Dimension::set_dim_param(::std::string&& value) {
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
if (!has_dim_param()) {
|
||
|
clear_value();
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
value_.dim_param_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorShapeProto_Dimension::set_dim_param(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
if (!has_dim_param()) {
|
||
|
clear_value();
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_dim_param(const char* value, size_t size) {
|
||
|
if (!has_dim_param()) {
|
||
|
clear_value();
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
value_.dim_param_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
||
|
reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
}
|
||
|
inline ::std::string* TensorShapeProto_Dimension::mutable_dim_param() {
|
||
|
if (!has_dim_param()) {
|
||
|
clear_value();
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
return value_.dim_param_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TensorShapeProto_Dimension::release_dim_param() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
if (has_dim_param()) {
|
||
|
clear_has_value();
|
||
|
return value_.dim_param_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
} else {
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_allocated_dim_param(::std::string* dim_param) {
|
||
|
if (!has_dim_param()) {
|
||
|
value_.dim_param_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
clear_value();
|
||
|
if (dim_param != NULL) {
|
||
|
set_has_dim_param();
|
||
|
value_.dim_param_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
dim_param);
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TensorShapeProto.Dimension.dim_param)
|
||
|
}
|
||
|
|
||
|
// optional string denotation = 3;
|
||
|
inline bool TensorShapeProto_Dimension::has_denotation() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_has_denotation() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::clear_has_denotation() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::clear_denotation() {
|
||
|
denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_denotation();
|
||
|
}
|
||
|
inline const ::std::string& TensorShapeProto_Dimension::denotation() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
return denotation_.GetNoArena();
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_denotation(const ::std::string& value) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TensorShapeProto_Dimension::set_denotation(::std::string&& value) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TensorShapeProto_Dimension::set_denotation(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_denotation(const char* value, size_t size) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
}
|
||
|
inline ::std::string* TensorShapeProto_Dimension::mutable_denotation() {
|
||
|
set_has_denotation();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TensorShapeProto_Dimension::release_denotation() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TensorShapeProto.Dimension.denotation)
|
||
|
clear_has_denotation();
|
||
|
return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void TensorShapeProto_Dimension::set_allocated_denotation(::std::string* denotation) {
|
||
|
if (denotation != NULL) {
|
||
|
set_has_denotation();
|
||
|
} else {
|
||
|
clear_has_denotation();
|
||
|
}
|
||
|
denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
|
||
|
// @@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::dim_size() const {
|
||
|
return dim_.size();
|
||
|
}
|
||
|
inline void TensorShapeProto::clear_dim() {
|
||
|
dim_.Clear();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorShapeProto_Dimension& TensorShapeProto::dim(int index) const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TensorShapeProto.dim)
|
||
|
return dim_.Get(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::mutable_dim(int index) {
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TensorShapeProto.dim)
|
||
|
return dim_.Mutable(index);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorShapeProto_Dimension* TensorShapeProto::add_dim() {
|
||
|
// @@protoc_insertion_point(field_add:opencv_onnx.TensorShapeProto.dim)
|
||
|
return dim_.Add();
|
||
|
}
|
||
|
inline ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >*
|
||
|
TensorShapeProto::mutable_dim() {
|
||
|
// @@protoc_insertion_point(field_mutable_list:opencv_onnx.TensorShapeProto.dim)
|
||
|
return &dim_;
|
||
|
}
|
||
|
inline const ::google::protobuf::RepeatedPtrField< ::opencv_onnx::TensorShapeProto_Dimension >&
|
||
|
TensorShapeProto::dim() const {
|
||
|
// @@protoc_insertion_point(field_list:opencv_onnx.TensorShapeProto.dim)
|
||
|
return dim_;
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// TypeProto_Tensor
|
||
|
|
||
|
// optional .opencv_onnx.TensorProto.DataType elem_type = 1;
|
||
|
inline bool TypeProto_Tensor::has_elem_type() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::set_has_elem_type() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::clear_has_elem_type() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::clear_elem_type() {
|
||
|
elem_type_ = 0;
|
||
|
clear_has_elem_type();
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorProto_DataType TypeProto_Tensor::elem_type() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.elem_type)
|
||
|
return static_cast< ::opencv_onnx::TensorProto_DataType >(elem_type_);
|
||
|
}
|
||
|
inline void TypeProto_Tensor::set_elem_type(::opencv_onnx::TensorProto_DataType value) {
|
||
|
assert(::opencv_onnx::TensorProto_DataType_IsValid(value));
|
||
|
set_has_elem_type();
|
||
|
elem_type_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.Tensor.elem_type)
|
||
|
}
|
||
|
|
||
|
// optional .opencv_onnx.TensorShapeProto shape = 2;
|
||
|
inline bool TypeProto_Tensor::has_shape() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::set_has_shape() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::clear_has_shape() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::clear_shape() {
|
||
|
if (shape_ != NULL) shape_->Clear();
|
||
|
clear_has_shape();
|
||
|
}
|
||
|
inline const ::opencv_onnx::TensorShapeProto& TypeProto_Tensor::shape() const {
|
||
|
const ::opencv_onnx::TensorShapeProto* p = shape_;
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.Tensor.shape)
|
||
|
return p != NULL ? *p : *reinterpret_cast<const ::opencv_onnx::TensorShapeProto*>(
|
||
|
&::opencv_onnx::_TensorShapeProto_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::release_shape() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.Tensor.shape)
|
||
|
clear_has_shape();
|
||
|
::opencv_onnx::TensorShapeProto* temp = shape_;
|
||
|
shape_ = NULL;
|
||
|
return temp;
|
||
|
}
|
||
|
inline ::opencv_onnx::TensorShapeProto* TypeProto_Tensor::mutable_shape() {
|
||
|
set_has_shape();
|
||
|
if (shape_ == NULL) {
|
||
|
shape_ = new ::opencv_onnx::TensorShapeProto;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.Tensor.shape)
|
||
|
return shape_;
|
||
|
}
|
||
|
inline void TypeProto_Tensor::set_allocated_shape(::opencv_onnx::TensorShapeProto* shape) {
|
||
|
::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
|
||
|
if (message_arena == NULL) {
|
||
|
delete shape_;
|
||
|
}
|
||
|
if (shape) {
|
||
|
::google::protobuf::Arena* submessage_arena = NULL;
|
||
|
if (message_arena != submessage_arena) {
|
||
|
shape = ::google::protobuf::internal::GetOwnedMessage(
|
||
|
message_arena, shape, submessage_arena);
|
||
|
}
|
||
|
set_has_shape();
|
||
|
} else {
|
||
|
clear_has_shape();
|
||
|
}
|
||
|
shape_ = shape;
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.Tensor.shape)
|
||
|
}
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// TypeProto
|
||
|
|
||
|
// optional .opencv_onnx.TypeProto.Tensor tensor_type = 1;
|
||
|
inline bool TypeProto::has_tensor_type() const {
|
||
|
return value_case() == kTensorType;
|
||
|
}
|
||
|
inline void TypeProto::set_has_tensor_type() {
|
||
|
_oneof_case_[0] = kTensorType;
|
||
|
}
|
||
|
inline void TypeProto::clear_tensor_type() {
|
||
|
if (has_tensor_type()) {
|
||
|
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 (has_tensor_type()) {
|
||
|
clear_has_value();
|
||
|
::opencv_onnx::TypeProto_Tensor* temp = value_.tensor_type_;
|
||
|
value_.tensor_type_ = NULL;
|
||
|
return temp;
|
||
|
} else {
|
||
|
return NULL;
|
||
|
}
|
||
|
}
|
||
|
inline const ::opencv_onnx::TypeProto_Tensor& TypeProto::tensor_type() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.tensor_type)
|
||
|
return has_tensor_type()
|
||
|
? *value_.tensor_type_
|
||
|
: *reinterpret_cast< ::opencv_onnx::TypeProto_Tensor*>(&::opencv_onnx::_TypeProto_Tensor_default_instance_);
|
||
|
}
|
||
|
inline ::opencv_onnx::TypeProto_Tensor* TypeProto::mutable_tensor_type() {
|
||
|
if (!has_tensor_type()) {
|
||
|
clear_value();
|
||
|
set_has_tensor_type();
|
||
|
value_.tensor_type_ = new ::opencv_onnx::TypeProto_Tensor;
|
||
|
}
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.tensor_type)
|
||
|
return value_.tensor_type_;
|
||
|
}
|
||
|
|
||
|
// optional string denotation = 6;
|
||
|
inline bool TypeProto::has_denotation() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void TypeProto::set_has_denotation() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void TypeProto::clear_has_denotation() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void TypeProto::clear_denotation() {
|
||
|
denotation_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_denotation();
|
||
|
}
|
||
|
inline const ::std::string& TypeProto::denotation() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.TypeProto.denotation)
|
||
|
return denotation_.GetNoArena();
|
||
|
}
|
||
|
inline void TypeProto::set_denotation(const ::std::string& value) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.TypeProto.denotation)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void TypeProto::set_denotation(::std::string&& value) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.TypeProto.denotation)
|
||
|
}
|
||
|
#endif
|
||
|
inline void TypeProto::set_denotation(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.TypeProto.denotation)
|
||
|
}
|
||
|
inline void TypeProto::set_denotation(const char* value, size_t size) {
|
||
|
set_has_denotation();
|
||
|
denotation_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.TypeProto.denotation)
|
||
|
}
|
||
|
inline ::std::string* TypeProto::mutable_denotation() {
|
||
|
set_has_denotation();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.TypeProto.denotation)
|
||
|
return denotation_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* TypeProto::release_denotation() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.TypeProto.denotation)
|
||
|
clear_has_denotation();
|
||
|
return denotation_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void TypeProto::set_allocated_denotation(::std::string* denotation) {
|
||
|
if (denotation != NULL) {
|
||
|
set_has_denotation();
|
||
|
} else {
|
||
|
clear_has_denotation();
|
||
|
}
|
||
|
denotation_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), denotation);
|
||
|
// @@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::has_domain() const {
|
||
|
return (_has_bits_[0] & 0x00000001u) != 0;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_has_domain() {
|
||
|
_has_bits_[0] |= 0x00000001u;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::clear_has_domain() {
|
||
|
_has_bits_[0] &= ~0x00000001u;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::clear_domain() {
|
||
|
domain_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
inline const ::std::string& OperatorSetIdProto::domain() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
return domain_.GetNoArena();
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_domain(const ::std::string& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
}
|
||
|
#if LANG_CXX11
|
||
|
inline void OperatorSetIdProto::set_domain(::std::string&& value) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(
|
||
|
&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
|
||
|
// @@protoc_insertion_point(field_set_rvalue:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
}
|
||
|
#endif
|
||
|
inline void OperatorSetIdProto::set_domain(const char* value) {
|
||
|
GOOGLE_DCHECK(value != NULL);
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
|
||
|
// @@protoc_insertion_point(field_set_char:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_domain(const char* value, size_t size) {
|
||
|
set_has_domain();
|
||
|
domain_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
|
||
|
::std::string(reinterpret_cast<const char*>(value), size));
|
||
|
// @@protoc_insertion_point(field_set_pointer:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
}
|
||
|
inline ::std::string* OperatorSetIdProto::mutable_domain() {
|
||
|
set_has_domain();
|
||
|
// @@protoc_insertion_point(field_mutable:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
return domain_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline ::std::string* OperatorSetIdProto::release_domain() {
|
||
|
// @@protoc_insertion_point(field_release:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
clear_has_domain();
|
||
|
return domain_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_allocated_domain(::std::string* domain) {
|
||
|
if (domain != NULL) {
|
||
|
set_has_domain();
|
||
|
} else {
|
||
|
clear_has_domain();
|
||
|
}
|
||
|
domain_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), domain);
|
||
|
// @@protoc_insertion_point(field_set_allocated:opencv_onnx.OperatorSetIdProto.domain)
|
||
|
}
|
||
|
|
||
|
// optional int64 version = 2;
|
||
|
inline bool OperatorSetIdProto::has_version() const {
|
||
|
return (_has_bits_[0] & 0x00000002u) != 0;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_has_version() {
|
||
|
_has_bits_[0] |= 0x00000002u;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::clear_has_version() {
|
||
|
_has_bits_[0] &= ~0x00000002u;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::clear_version() {
|
||
|
version_ = GOOGLE_LONGLONG(0);
|
||
|
clear_has_version();
|
||
|
}
|
||
|
inline ::google::protobuf::int64 OperatorSetIdProto::version() const {
|
||
|
// @@protoc_insertion_point(field_get:opencv_onnx.OperatorSetIdProto.version)
|
||
|
return version_;
|
||
|
}
|
||
|
inline void OperatorSetIdProto::set_version(::google::protobuf::int64 value) {
|
||
|
set_has_version();
|
||
|
version_ = value;
|
||
|
// @@protoc_insertion_point(field_set:opencv_onnx.OperatorSetIdProto.version)
|
||
|
}
|
||
|
|
||
|
#ifdef __GNUC__
|
||
|
#pragma GCC diagnostic pop
|
||
|
#endif // __GNUC__
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
// -------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
// @@protoc_insertion_point(namespace_scope)
|
||
|
|
||
|
} // namespace opencv_onnx
|
||
|
|
||
|
namespace google {
|
||
|
namespace protobuf {
|
||
|
|
||
|
template <> struct is_proto_enum< ::opencv_onnx::AttributeProto_AttributeType> : ::google::protobuf::internal::true_type {};
|
||
|
template <>
|
||
|
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::AttributeProto_AttributeType>() {
|
||
|
return ::opencv_onnx::AttributeProto_AttributeType_descriptor();
|
||
|
}
|
||
|
template <> struct is_proto_enum< ::opencv_onnx::TensorProto_DataType> : ::google::protobuf::internal::true_type {};
|
||
|
template <>
|
||
|
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::TensorProto_DataType>() {
|
||
|
return ::opencv_onnx::TensorProto_DataType_descriptor();
|
||
|
}
|
||
|
template <> struct is_proto_enum< ::opencv_onnx::Version> : ::google::protobuf::internal::true_type {};
|
||
|
template <>
|
||
|
inline const EnumDescriptor* GetEnumDescriptor< ::opencv_onnx::Version>() {
|
||
|
return ::opencv_onnx::Version_descriptor();
|
||
|
}
|
||
|
|
||
|
} // namespace protobuf
|
||
|
} // namespace google
|
||
|
|
||
|
// @@protoc_insertion_point(global_scope)
|
||
|
|
||
|
#endif // PROTOBUF_opencv_2donnx_2eproto__INCLUDED
|