From 0c8590027f3c1b9f1f6b50d71b42ba3bbfbaa11c Mon Sep 17 00:00:00 2001 From: Lubov Batanina Date: Mon, 10 Sep 2018 21:07:51 +0300 Subject: [PATCH] Merge pull request #12071 from l-bat/l-bat:onnx_parser * Add Squeezenet support in ONNX * Add AlexNet support in ONNX * Add Googlenet support in ONNX * Add CaffeNet and RCNN support in ONNX * Add VGG16 and VGG16 with batch normalization support in ONNX * Add RCNN, ZFNet, ResNet18v1 and ResNet50v1 support in ONNX * Add ResNet101_DUC_HDC * Add Tiny Yolov2 * Add CNN_MNIST, MobileNetv2 and LResNet100 support in ONNX * Add ONNX models for emotion recognition * Add DenseNet121 support in ONNX * Add Inception v1 support in ONNX * Refactoring * Fix tests * Fix tests * Skip unstable test * Modify Reshape operation --- modules/dnn/CMakeLists.txt | 8 +- modules/dnn/include/opencv2/dnn/dict.hpp | 3 + modules/dnn/include/opencv2/dnn/dnn.hpp | 12 + modules/dnn/include/opencv2/dnn/dnn.inl.hpp | 5 + modules/dnn/misc/onnx/opencv-onnx.pb.cc | 6977 +++++++++++++++++++ modules/dnn/misc/onnx/opencv-onnx.pb.h | 5849 ++++++++++++++++ modules/dnn/src/dnn.cpp | 4 + modules/dnn/src/onnx/onnx_importer.cpp | 585 ++ modules/dnn/src/onnx/opencv-onnx.proto | 446 ++ modules/dnn/test/test_onnx_importer.cpp | 344 + 10 files changed, 14229 insertions(+), 4 deletions(-) create mode 100644 modules/dnn/misc/onnx/opencv-onnx.pb.cc create mode 100644 modules/dnn/misc/onnx/opencv-onnx.pb.h create mode 100644 modules/dnn/src/onnx/onnx_importer.cpp create mode 100644 modules/dnn/src/onnx/opencv-onnx.proto create mode 100644 modules/dnn/test/test_onnx_importer.cpp diff --git a/modules/dnn/CMakeLists.txt b/modules/dnn/CMakeLists.txt index 40b573f45a..52416731ff 100644 --- a/modules/dnn/CMakeLists.txt +++ b/modules/dnn/CMakeLists.txt @@ -67,13 +67,13 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS ) if(PROTOBUF_UPDATE_FILES) - file(GLOB proto_files "${CMAKE_CURRENT_LIST_DIR}/src/tensorflow/*.proto" "${CMAKE_CURRENT_LIST_DIR}/src/caffe/opencv-caffe.proto") + file(GLOB proto_files "${CMAKE_CURRENT_LIST_DIR}/src/tensorflow/*.proto" "${CMAKE_CURRENT_LIST_DIR}/src/caffe/opencv-caffe.proto" "${CMAKE_CURRENT_LIST_DIR}/src/onnx/opencv-onnx.proto") set(PROTOBUF_GENERATE_CPP_APPEND_PATH ON) # required for tensorflow protobuf_generate_cpp(fw_srcs fw_hdrs ${proto_files}) else() - file(GLOB fw_srcs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.cc") - file(GLOB fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.h" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.h") - set(fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/caffe" "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow") + file(GLOB fw_srcs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.cc" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.cc") + file(GLOB fw_hdrs "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow/*.h" "${CMAKE_CURRENT_LIST_DIR}/misc/caffe/opencv-caffe.pb.h" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx/opencv-onnx.pb.h") + set(fw_inc "${CMAKE_CURRENT_LIST_DIR}/misc/caffe" "${CMAKE_CURRENT_LIST_DIR}/misc/tensorflow" "${CMAKE_CURRENT_LIST_DIR}/misc/onnx") endif() set(include_dirs ${fw_inc}) diff --git a/modules/dnn/include/opencv2/dnn/dict.hpp b/modules/dnn/include/opencv2/dnn/dict.hpp index 69287dc1cc..850e17f0b2 100644 --- a/modules/dnn/include/opencv2/dnn/dict.hpp +++ b/modules/dnn/include/opencv2/dnn/dict.hpp @@ -141,6 +141,9 @@ public: template const T &set(const String &key, const T &value); + //! Erase @p key from the dictionary. + void erase(const String &key); + friend std::ostream &operator<<(std::ostream &stream, const Dict &dict); std::map::const_iterator begin() const; diff --git a/modules/dnn/include/opencv2/dnn/dnn.hpp b/modules/dnn/include/opencv2/dnn/dnn.hpp index 0736e8aa4a..ccb4c85635 100644 --- a/modules/dnn/include/opencv2/dnn/dnn.hpp +++ b/modules/dnn/include/opencv2/dnn/dnn.hpp @@ -814,6 +814,18 @@ CV__DNN_EXPERIMENTAL_NS_BEGIN */ CV_EXPORTS_W Net readNetFromModelOptimizer(const String &xml, const String &bin); + /** @brief Reads a network model ONNX. + * @param onnxFile path to the .onnx file with text description of the network architecture. + * @returns Network object that ready to do forward, throw an exception in failure cases. + */ + CV_EXPORTS_W Net readNetFromONNX(const String &onnxFile); + + /** @brief Creates blob from .pb file. + * @param path to the .pb file with input tensor. + * @returns Mat. + */ + CV_EXPORTS_W Mat readTensorFromONNX(const String& path); + /** @brief Creates 4-dimensional blob from image. Optionally resizes and crops @p image from center, * subtract @p mean values, scales values by @p scalefactor, swap Blue and Red channels. * @param image input image (with 1-, 3- or 4-channels). diff --git a/modules/dnn/include/opencv2/dnn/dnn.inl.hpp b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp index 4231896187..17d4c200bd 100644 --- a/modules/dnn/include/opencv2/dnn/dnn.inl.hpp +++ b/modules/dnn/include/opencv2/dnn/dnn.inl.hpp @@ -364,6 +364,11 @@ inline const T &Dict::set(const String &key, const T &value) return value; } +inline void Dict::erase(const String &key) +{ + dict.erase(key); +} + inline std::ostream &operator<<(std::ostream &stream, const Dict &dict) { Dict::_Dict::const_iterator it; diff --git a/modules/dnn/misc/onnx/opencv-onnx.pb.cc b/modules/dnn/misc/onnx/opencv-onnx.pb.cc new file mode 100644 index 0000000000..6d7049623d --- /dev/null +++ b/modules/dnn/misc/onnx/opencv-onnx.pb.cc @@ -0,0 +1,6977 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: opencv-onnx.proto + +#include "opencv-onnx.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +// This is a temporary google only hack +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS +#include "third_party/protobuf/version.h" +#endif +// @@protoc_insertion_point(includes) +namespace opencv_onnx { +class AttributeProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _AttributeProto_default_instance_; +class ValueInfoProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _ValueInfoProto_default_instance_; +class NodeProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _NodeProto_default_instance_; +class ModelProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _ModelProto_default_instance_; +class StringStringEntryProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _StringStringEntryProto_default_instance_; +class GraphProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _GraphProto_default_instance_; +class TensorProto_SegmentDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _TensorProto_Segment_default_instance_; +class TensorProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _TensorProto_default_instance_; +class TensorShapeProto_DimensionDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; + ::google::protobuf::int64 dim_value_; + ::google::protobuf::internal::ArenaStringPtr dim_param_; +} _TensorShapeProto_Dimension_default_instance_; +class TensorShapeProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _TensorShapeProto_default_instance_; +class TypeProto_TensorDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _TypeProto_Tensor_default_instance_; +class TypeProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; + const ::opencv_onnx::TypeProto_Tensor* tensor_type_; +} _TypeProto_default_instance_; +class OperatorSetIdProtoDefaultTypeInternal { + public: + ::google::protobuf::internal::ExplicitlyConstructed + _instance; +} _OperatorSetIdProto_default_instance_; +} // namespace opencv_onnx +namespace protobuf_opencv_2donnx_2eproto { +void InitDefaultsAttributeProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto(); + protobuf_opencv_2donnx_2eproto::InitDefaultsValueInfoProto(); + { + void* ptr = &::opencv_onnx::_AttributeProto_default_instance_; + new (ptr) ::opencv_onnx::AttributeProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + { + void* ptr = &::opencv_onnx::_NodeProto_default_instance_; + new (ptr) ::opencv_onnx::NodeProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + { + void* ptr = &::opencv_onnx::_GraphProto_default_instance_; + new (ptr) ::opencv_onnx::GraphProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::AttributeProto::InitAsDefaultInstance(); + ::opencv_onnx::NodeProto::InitAsDefaultInstance(); + ::opencv_onnx::GraphProto::InitAsDefaultInstance(); +} + +void InitDefaultsAttributeProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsAttributeProtoImpl); +} + +void InitDefaultsValueInfoProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto(); + { + void* ptr = &::opencv_onnx::_ValueInfoProto_default_instance_; + new (ptr) ::opencv_onnx::ValueInfoProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::ValueInfoProto::InitAsDefaultInstance(); +} + +void InitDefaultsValueInfoProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsValueInfoProtoImpl); +} + +void InitDefaultsModelProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsOperatorSetIdProto(); + protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + protobuf_opencv_2donnx_2eproto::InitDefaultsStringStringEntryProto(); + { + void* ptr = &::opencv_onnx::_ModelProto_default_instance_; + new (ptr) ::opencv_onnx::ModelProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::ModelProto::InitAsDefaultInstance(); +} + +void InitDefaultsModelProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsModelProtoImpl); +} + +void InitDefaultsStringStringEntryProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + { + void* ptr = &::opencv_onnx::_StringStringEntryProto_default_instance_; + new (ptr) ::opencv_onnx::StringStringEntryProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::StringStringEntryProto::InitAsDefaultInstance(); +} + +void InitDefaultsStringStringEntryProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsStringStringEntryProtoImpl); +} + +void InitDefaultsTensorProto_SegmentImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + { + void* ptr = &::opencv_onnx::_TensorProto_Segment_default_instance_; + new (ptr) ::opencv_onnx::TensorProto_Segment(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TensorProto_Segment::InitAsDefaultInstance(); +} + +void InitDefaultsTensorProto_Segment() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTensorProto_SegmentImpl); +} + +void InitDefaultsTensorProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto_Segment(); + { + void* ptr = &::opencv_onnx::_TensorProto_default_instance_; + new (ptr) ::opencv_onnx::TensorProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TensorProto::InitAsDefaultInstance(); +} + +void InitDefaultsTensorProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTensorProtoImpl); +} + +void InitDefaultsTensorShapeProto_DimensionImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + { + void* ptr = &::opencv_onnx::_TensorShapeProto_Dimension_default_instance_; + new (ptr) ::opencv_onnx::TensorShapeProto_Dimension(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TensorShapeProto_Dimension::InitAsDefaultInstance(); +} + +void InitDefaultsTensorShapeProto_Dimension() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTensorShapeProto_DimensionImpl); +} + +void InitDefaultsTensorShapeProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto_Dimension(); + { + void* ptr = &::opencv_onnx::_TensorShapeProto_default_instance_; + new (ptr) ::opencv_onnx::TensorShapeProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TensorShapeProto::InitAsDefaultInstance(); +} + +void InitDefaultsTensorShapeProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTensorShapeProtoImpl); +} + +void InitDefaultsTypeProto_TensorImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto(); + { + void* ptr = &::opencv_onnx::_TypeProto_Tensor_default_instance_; + new (ptr) ::opencv_onnx::TypeProto_Tensor(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TypeProto_Tensor::InitAsDefaultInstance(); +} + +void InitDefaultsTypeProto_Tensor() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTypeProto_TensorImpl); +} + +void InitDefaultsTypeProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto_Tensor(); + { + void* ptr = &::opencv_onnx::_TypeProto_default_instance_; + new (ptr) ::opencv_onnx::TypeProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::TypeProto::InitAsDefaultInstance(); +} + +void InitDefaultsTypeProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTypeProtoImpl); +} + +void InitDefaultsOperatorSetIdProtoImpl() { + GOOGLE_PROTOBUF_VERIFY_VERSION; + +#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); +#else + ::google::protobuf::internal::InitProtobufDefaults(); +#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS + { + void* ptr = &::opencv_onnx::_OperatorSetIdProto_default_instance_; + new (ptr) ::opencv_onnx::OperatorSetIdProto(); + ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); + } + ::opencv_onnx::OperatorSetIdProto::InitAsDefaultInstance(); +} + +void InitDefaultsOperatorSetIdProto() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsOperatorSetIdProtoImpl); +} + +::google::protobuf::Metadata file_level_metadata[13]; +const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[3]; + +const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, ref_attr_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, doc_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, f_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, i_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, s_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, t_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, g_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, floats_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, ints_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, strings_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, tensors_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::AttributeProto, graphs_), + 0, + 3, + 2, + 8, + 7, + 6, + 1, + 4, + 5, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ValueInfoProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ValueInfoProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ValueInfoProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ValueInfoProto, type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ValueInfoProto, doc_string_), + 0, + 2, + 1, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, input_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, op_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, domain_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, attribute_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::NodeProto, doc_string_), + ~0u, + ~0u, + 0, + 1, + 3, + ~0u, + 2, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, ir_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, opset_import_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, producer_name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, producer_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, domain_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, model_version_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, doc_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, graph_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::ModelProto, metadata_props_), + 5, + ~0u, + 0, + 1, + 2, + 6, + 3, + 4, + ~0u, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::StringStringEntryProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::StringStringEntryProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::StringStringEntryProto, key_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::StringStringEntryProto, value_), + 0, + 1, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, node_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, initializer_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, doc_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, input_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, output_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::GraphProto, value_info_), + ~0u, + 0, + ~0u, + 1, + ~0u, + ~0u, + ~0u, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto_Segment, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto_Segment, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto_Segment, begin_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto_Segment, end_), + 0, + 1, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, dims_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, data_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, segment_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, float_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, int32_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, string_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, int64_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, doc_string_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, raw_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, double_data_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorProto, uint64_data_), + ~0u, + 4, + 3, + ~0u, + ~0u, + ~0u, + ~0u, + 0, + 2, + 1, + ~0u, + ~0u, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto_Dimension, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto_Dimension, _internal_metadata_), + ~0u, // no _extensions_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto_Dimension, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::opencv_onnx::TensorShapeProto_DimensionDefaultTypeInternal, dim_value_), + offsetof(::opencv_onnx::TensorShapeProto_DimensionDefaultTypeInternal, dim_param_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto_Dimension, denotation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto_Dimension, value_), + ~0u, + ~0u, + 0, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TensorShapeProto, dim_), + ~0u, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto_Tensor, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto_Tensor, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto_Tensor, elem_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto_Tensor, shape_), + 1, + 0, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto, _internal_metadata_), + ~0u, // no _extensions_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + offsetof(::opencv_onnx::TypeProtoDefaultTypeInternal, tensor_type_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto, denotation_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::TypeProto, value_), + ~0u, + 0, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::OperatorSetIdProto, _has_bits_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::OperatorSetIdProto, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::OperatorSetIdProto, domain_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_onnx::OperatorSetIdProto, version_), + 0, + 1, +}; +static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + { 0, 19, sizeof(::opencv_onnx::AttributeProto)}, + { 33, 41, sizeof(::opencv_onnx::ValueInfoProto)}, + { 44, 56, sizeof(::opencv_onnx::NodeProto)}, + { 63, 77, sizeof(::opencv_onnx::ModelProto)}, + { 86, 93, sizeof(::opencv_onnx::StringStringEntryProto)}, + { 95, 107, sizeof(::opencv_onnx::GraphProto)}, + { 114, 121, sizeof(::opencv_onnx::TensorProto_Segment)}, + { 123, 140, sizeof(::opencv_onnx::TensorProto)}, + { 152, 161, sizeof(::opencv_onnx::TensorShapeProto_Dimension)}, + { 164, 170, sizeof(::opencv_onnx::TensorShapeProto)}, + { 171, 178, sizeof(::opencv_onnx::TypeProto_Tensor)}, + { 180, 188, sizeof(::opencv_onnx::TypeProto)}, + { 190, 197, sizeof(::opencv_onnx::OperatorSetIdProto)}, +}; + +static ::google::protobuf::Message const * const file_default_instances[] = { + reinterpret_cast(&::opencv_onnx::_AttributeProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_ValueInfoProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_NodeProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_ModelProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_StringStringEntryProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_GraphProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_TensorProto_Segment_default_instance_), + reinterpret_cast(&::opencv_onnx::_TensorProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_TensorShapeProto_Dimension_default_instance_), + reinterpret_cast(&::opencv_onnx::_TensorShapeProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_TypeProto_Tensor_default_instance_), + reinterpret_cast(&::opencv_onnx::_TypeProto_default_instance_), + reinterpret_cast(&::opencv_onnx::_OperatorSetIdProto_default_instance_), +}; + +void protobuf_AssignDescriptors() { + AddDescriptors(); + ::google::protobuf::MessageFactory* factory = NULL; + AssignDescriptors( + "opencv-onnx.proto", schemas, file_default_instances, TableStruct::offsets, factory, + file_level_metadata, file_level_enum_descriptors, NULL); +} + +void protobuf_AssignDescriptorsOnce() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors); +} + +void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD; +void protobuf_RegisterTypes(const ::std::string&) { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 13); +} + +void AddDescriptorsImpl() { + InitDefaults(); + static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + "\n\021opencv-onnx.proto\022\013opencv_onnx\"\203\004\n\016Att" + "ributeProto\022\014\n\004name\030\001 \001(\t\022\025\n\rref_attr_na" + "me\030\025 \001(\t\022\022\n\ndoc_string\030\r \001(\t\0227\n\004type\030\024 \001" + "(\0162).opencv_onnx.AttributeProto.Attribut" + "eType\022\t\n\001f\030\002 \001(\002\022\t\n\001i\030\003 \001(\003\022\t\n\001s\030\004 \001(\014\022#" + "\n\001t\030\005 \001(\0132\030.opencv_onnx.TensorProto\022\"\n\001g" + "\030\006 \001(\0132\027.opencv_onnx.GraphProto\022\016\n\006float" + "s\030\007 \003(\002\022\014\n\004ints\030\010 \003(\003\022\017\n\007strings\030\t \003(\014\022)" + "\n\007tensors\030\n \003(\0132\030.opencv_onnx.TensorProt" + "o\022\'\n\006graphs\030\013 \003(\0132\027.opencv_onnx.GraphPro" + "to\"\221\001\n\rAttributeType\022\r\n\tUNDEFINED\020\000\022\t\n\005F" + "LOAT\020\001\022\007\n\003INT\020\002\022\n\n\006STRING\020\003\022\n\n\006TENSOR\020\004\022" + "\t\n\005GRAPH\020\005\022\n\n\006FLOATS\020\006\022\010\n\004INTS\020\007\022\013\n\007STRI" + "NGS\020\010\022\013\n\007TENSORS\020\t\022\n\n\006GRAPHS\020\n\"X\n\016ValueI" + "nfoProto\022\014\n\004name\030\001 \001(\t\022$\n\004type\030\002 \001(\0132\026.o" + "pencv_onnx.TypeProto\022\022\n\ndoc_string\030\003 \001(\t" + "\"\235\001\n\tNodeProto\022\r\n\005input\030\001 \003(\t\022\016\n\006output\030" + "\002 \003(\t\022\014\n\004name\030\003 \001(\t\022\017\n\007op_type\030\004 \001(\t\022\016\n\006" + "domain\030\007 \001(\t\022.\n\tattribute\030\005 \003(\0132\033.opencv" + "_onnx.AttributeProto\022\022\n\ndoc_string\030\006 \001(\t" + "\"\250\002\n\nModelProto\022\022\n\nir_version\030\001 \001(\003\0225\n\014o" + "pset_import\030\010 \003(\0132\037.opencv_onnx.Operator" + "SetIdProto\022\025\n\rproducer_name\030\002 \001(\t\022\030\n\020pro" + "ducer_version\030\003 \001(\t\022\016\n\006domain\030\004 \001(\t\022\025\n\rm" + "odel_version\030\005 \001(\003\022\022\n\ndoc_string\030\006 \001(\t\022&" + "\n\005graph\030\007 \001(\0132\027.opencv_onnx.GraphProto\022;" + "\n\016metadata_props\030\016 \003(\0132#.opencv_onnx.Str" + "ingStringEntryProto\"4\n\026StringStringEntry" + "Proto\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t\"\215\002\n\nGr" + "aphProto\022$\n\004node\030\001 \003(\0132\026.opencv_onnx.Nod" + "eProto\022\014\n\004name\030\002 \001(\t\022-\n\013initializer\030\005 \003(" + "\0132\030.opencv_onnx.TensorProto\022\022\n\ndoc_strin" + "g\030\n \001(\t\022*\n\005input\030\013 \003(\0132\033.opencv_onnx.Val" + "ueInfoProto\022+\n\006output\030\014 \003(\0132\033.opencv_onn" + "x.ValueInfoProto\022/\n\nvalue_info\030\r \003(\0132\033.o" + "pencv_onnx.ValueInfoProto\"\275\004\n\013TensorProt" + "o\022\014\n\004dims\030\001 \003(\003\0224\n\tdata_type\030\002 \001(\0162!.ope" + "ncv_onnx.TensorProto.DataType\0221\n\007segment" + "\030\003 \001(\0132 .opencv_onnx.TensorProto.Segment" + "\022\026\n\nfloat_data\030\004 \003(\002B\002\020\001\022\026\n\nint32_data\030\005" + " \003(\005B\002\020\001\022\023\n\013string_data\030\006 \003(\014\022\026\n\nint64_d" + "ata\030\007 \003(\003B\002\020\001\022\014\n\004name\030\010 \001(\t\022\022\n\ndoc_strin" + "g\030\014 \001(\t\022\020\n\010raw_data\030\t \001(\014\022\027\n\013double_data" + "\030\n \003(\001B\002\020\001\022\027\n\013uint64_data\030\013 \003(\004B\002\020\001\032%\n\007S" + "egment\022\r\n\005begin\030\001 \001(\003\022\013\n\003end\030\002 \001(\003\"\314\001\n\010D" + "ataType\022\r\n\tUNDEFINED\020\000\022\t\n\005FLOAT\020\001\022\t\n\005UIN" + "T8\020\002\022\010\n\004INT8\020\003\022\n\n\006UINT16\020\004\022\t\n\005INT16\020\005\022\t\n" + "\005INT32\020\006\022\t\n\005INT64\020\007\022\n\n\006STRING\020\010\022\010\n\004BOOL\020" + "\t\022\013\n\007FLOAT16\020\n\022\n\n\006DOUBLE\020\013\022\n\n\006UINT32\020\014\022\n" + "\n\006UINT64\020\r\022\r\n\tCOMPLEX64\020\016\022\016\n\nCOMPLEX128\020" + "\017\"\234\001\n\020TensorShapeProto\0224\n\003dim\030\001 \003(\0132\'.op" + "encv_onnx.TensorShapeProto.Dimension\032R\n\t" + "Dimension\022\023\n\tdim_value\030\001 \001(\003H\000\022\023\n\tdim_pa" + "ram\030\002 \001(\tH\000\022\022\n\ndenotation\030\003 \001(\tB\007\n\005value" + "\"\314\001\n\tTypeProto\0224\n\013tensor_type\030\001 \001(\0132\035.op" + "encv_onnx.TypeProto.TensorH\000\022\022\n\ndenotati" + "on\030\006 \001(\t\032l\n\006Tensor\0224\n\telem_type\030\001 \001(\0162!." + "opencv_onnx.TensorProto.DataType\022,\n\005shap" + "e\030\002 \001(\0132\035.opencv_onnx.TensorShapeProtoB\007" + "\n\005value\"5\n\022OperatorSetIdProto\022\016\n\006domain\030" + "\001 \001(\t\022\017\n\007version\030\002 \001(\003*c\n\007Version\022\022\n\016_ST" + "ART_VERSION\020\000\022\031\n\025IR_VERSION_2017_10_10\020\001" + "\022\031\n\025IR_VERSION_2017_10_30\020\002\022\016\n\nIR_VERSIO" + "N\020\003" + }; + ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( + descriptor, 2523); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( + "opencv-onnx.proto", &protobuf_RegisterTypes); +} + +void AddDescriptors() { + static GOOGLE_PROTOBUF_DECLARE_ONCE(once); + ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl); +} +// Force AddDescriptors() to be called at dynamic initialization time. +struct StaticDescriptorInitializer { + StaticDescriptorInitializer() { + AddDescriptors(); + } +} static_descriptor_initializer; +} // namespace protobuf_opencv_2donnx_2eproto +namespace opencv_onnx { +const ::google::protobuf::EnumDescriptor* AttributeProto_AttributeType_descriptor() { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return protobuf_opencv_2donnx_2eproto::file_level_enum_descriptors[0]; +} +bool AttributeProto_AttributeType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const AttributeProto_AttributeType AttributeProto::UNDEFINED; +const AttributeProto_AttributeType AttributeProto::FLOAT; +const AttributeProto_AttributeType AttributeProto::INT; +const AttributeProto_AttributeType AttributeProto::STRING; +const AttributeProto_AttributeType AttributeProto::TENSOR; +const AttributeProto_AttributeType AttributeProto::GRAPH; +const AttributeProto_AttributeType AttributeProto::FLOATS; +const AttributeProto_AttributeType AttributeProto::INTS; +const AttributeProto_AttributeType AttributeProto::STRINGS; +const AttributeProto_AttributeType AttributeProto::TENSORS; +const AttributeProto_AttributeType AttributeProto::GRAPHS; +const AttributeProto_AttributeType AttributeProto::AttributeType_MIN; +const AttributeProto_AttributeType AttributeProto::AttributeType_MAX; +const int AttributeProto::AttributeType_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* TensorProto_DataType_descriptor() { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return protobuf_opencv_2donnx_2eproto::file_level_enum_descriptors[1]; +} +bool TensorProto_DataType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + case 13: + case 14: + case 15: + return true; + default: + return false; + } +} + +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const TensorProto_DataType TensorProto::UNDEFINED; +const TensorProto_DataType TensorProto::FLOAT; +const TensorProto_DataType TensorProto::UINT8; +const TensorProto_DataType TensorProto::INT8; +const TensorProto_DataType TensorProto::UINT16; +const TensorProto_DataType TensorProto::INT16; +const TensorProto_DataType TensorProto::INT32; +const TensorProto_DataType TensorProto::INT64; +const TensorProto_DataType TensorProto::STRING; +const TensorProto_DataType TensorProto::BOOL; +const TensorProto_DataType TensorProto::FLOAT16; +const TensorProto_DataType TensorProto::DOUBLE; +const TensorProto_DataType TensorProto::UINT32; +const TensorProto_DataType TensorProto::UINT64; +const TensorProto_DataType TensorProto::COMPLEX64; +const TensorProto_DataType TensorProto::COMPLEX128; +const TensorProto_DataType TensorProto::DataType_MIN; +const TensorProto_DataType TensorProto::DataType_MAX; +const int TensorProto::DataType_ARRAYSIZE; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 +const ::google::protobuf::EnumDescriptor* Version_descriptor() { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return protobuf_opencv_2donnx_2eproto::file_level_enum_descriptors[2]; +} +bool Version_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + return true; + default: + return false; + } +} + + +// =================================================================== + +void AttributeProto::InitAsDefaultInstance() { + ::opencv_onnx::_AttributeProto_default_instance_._instance.get_mutable()->t_ = const_cast< ::opencv_onnx::TensorProto*>( + ::opencv_onnx::TensorProto::internal_default_instance()); + ::opencv_onnx::_AttributeProto_default_instance_._instance.get_mutable()->g_ = const_cast< ::opencv_onnx::GraphProto*>( + ::opencv_onnx::GraphProto::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int AttributeProto::kNameFieldNumber; +const int AttributeProto::kRefAttrNameFieldNumber; +const int AttributeProto::kDocStringFieldNumber; +const int AttributeProto::kTypeFieldNumber; +const int AttributeProto::kFFieldNumber; +const int AttributeProto::kIFieldNumber; +const int AttributeProto::kSFieldNumber; +const int AttributeProto::kTFieldNumber; +const int AttributeProto::kGFieldNumber; +const int AttributeProto::kFloatsFieldNumber; +const int AttributeProto::kIntsFieldNumber; +const int AttributeProto::kStringsFieldNumber; +const int AttributeProto::kTensorsFieldNumber; +const int AttributeProto::kGraphsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +AttributeProto::AttributeProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.AttributeProto) +} +AttributeProto::AttributeProto(const AttributeProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + floats_(from.floats_), + ints_(from.ints_), + strings_(from.strings_), + tensors_(from.tensors_), + graphs_(from.graphs_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_name()) { + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_s()) { + s_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.s_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + ref_attr_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_ref_attr_name()) { + ref_attr_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ref_attr_name_); + } + if (from.has_t()) { + t_ = new ::opencv_onnx::TensorProto(*from.t_); + } else { + t_ = NULL; + } + if (from.has_g()) { + g_ = new ::opencv_onnx::GraphProto(*from.g_); + } else { + g_ = NULL; + } + ::memcpy(&i_, &from.i_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&i_)) + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:opencv_onnx.AttributeProto) +} + +void AttributeProto::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + s_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ref_attr_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&t_, 0, static_cast( + reinterpret_cast(&type_) - + reinterpret_cast(&t_)) + sizeof(type_)); +} + +AttributeProto::~AttributeProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.AttributeProto) + SharedDtor(); +} + +void AttributeProto::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + s_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ref_attr_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete t_; + if (this != internal_default_instance()) delete g_; +} + +void AttributeProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* AttributeProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const AttributeProto& AttributeProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + return *internal_default_instance(); +} + +AttributeProto* AttributeProto::New(::google::protobuf::Arena* arena) const { + AttributeProto* n = new AttributeProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void AttributeProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.AttributeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + floats_.Clear(); + ints_.Clear(); + strings_.Clear(); + tensors_.Clear(); + graphs_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 63u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!s_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*s_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(!ref_attr_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*ref_attr_name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(t_ != NULL); + t_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(g_ != NULL); + g_->Clear(); + } + } + if (cached_has_bits & 192u) { + ::memset(&i_, 0, static_cast( + reinterpret_cast(&f_) - + reinterpret_cast(&i_)) + sizeof(f_)); + } + type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool AttributeProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.AttributeProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.AttributeProto.name"); + } else { + goto handle_unusual; + } + break; + } + + // optional float f = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) { + set_has_f(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, &f_))); + } else { + goto handle_unusual; + } + break; + } + + // optional int64 i = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { + set_has_i(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &i_))); + } else { + goto handle_unusual; + } + break; + } + + // optional bytes s = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_s())); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.TensorProto t = 5; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_t())); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.GraphProto g = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_g())); + } else { + goto handle_unusual; + } + break; + } + + // repeated float floats = 7; + case 7: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 61u, input, this->mutable_floats()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_floats()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 ints = 8; + case 8: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 64u, input, this->mutable_ints()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_ints()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated bytes strings = 9; + case 9: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->add_strings())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.TensorProto tensors = 10; + case 10: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tensors())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.GraphProto graphs = 11; + case 11: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_graphs())); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 13; + case 13: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.AttributeProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.AttributeProto.AttributeType type = 20; + case 20: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(160u /* 160 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::opencv_onnx::AttributeProto_AttributeType_IsValid(value)) { + set_type(static_cast< ::opencv_onnx::AttributeProto_AttributeType >(value)); + } else { + mutable_unknown_fields()->AddVarint( + 20, static_cast< ::google::protobuf::uint64>(value)); + } + } else { + goto handle_unusual; + } + break; + } + + // optional string ref_attr_name = 21; + case 21: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(170u /* 170 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_ref_attr_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ref_attr_name().data(), static_cast(this->ref_attr_name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.AttributeProto.ref_attr_name"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.AttributeProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.AttributeProto) + return false; +#undef DO_ +} + +void AttributeProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.AttributeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional float f = 2; + if (cached_has_bits & 0x00000080u) { + ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->f(), output); + } + + // optional int64 i = 3; + if (cached_has_bits & 0x00000040u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->i(), output); + } + + // optional bytes s = 4; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 4, this->s(), output); + } + + // optional .opencv_onnx.TensorProto t = 5; + if (cached_has_bits & 0x00000010u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, *this->t_, output); + } + + // optional .opencv_onnx.GraphProto g = 6; + if (cached_has_bits & 0x00000020u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 6, *this->g_, output); + } + + // repeated float floats = 7; + for (int i = 0, n = this->floats_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteFloat( + 7, this->floats(i), output); + } + + // repeated int64 ints = 8; + for (int i = 0, n = this->ints_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64( + 8, this->ints(i), output); + } + + // repeated bytes strings = 9; + for (int i = 0, n = this->strings_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 9, this->strings(i), output); + } + + // repeated .opencv_onnx.TensorProto tensors = 10; + for (unsigned int i = 0, + n = static_cast(this->tensors_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 10, this->tensors(static_cast(i)), output); + } + + // repeated .opencv_onnx.GraphProto graphs = 11; + for (unsigned int i = 0, + n = static_cast(this->graphs_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->graphs(static_cast(i)), output); + } + + // optional string doc_string = 13; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 13, this->doc_string(), output); + } + + // optional .opencv_onnx.AttributeProto.AttributeType type = 20; + if (cached_has_bits & 0x00000100u) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 20, this->type(), output); + } + + // optional string ref_attr_name = 21; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ref_attr_name().data(), static_cast(this->ref_attr_name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.ref_attr_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 21, this->ref_attr_name(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.AttributeProto) +} + +::google::protobuf::uint8* AttributeProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.AttributeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional float f = 2; + if (cached_has_bits & 0x00000080u) { + target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->f(), target); + } + + // optional int64 i = 3; + if (cached_has_bits & 0x00000040u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->i(), target); + } + + // optional bytes s = 4; + if (cached_has_bits & 0x00000002u) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 4, this->s(), target); + } + + // optional .opencv_onnx.TensorProto t = 5; + if (cached_has_bits & 0x00000010u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, *this->t_, deterministic, target); + } + + // optional .opencv_onnx.GraphProto g = 6; + if (cached_has_bits & 0x00000020u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 6, *this->g_, deterministic, target); + } + + // repeated float floats = 7; + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatToArray(7, this->floats_, target); + + // repeated int64 ints = 8; + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArray(8, this->ints_, target); + + // repeated bytes strings = 9; + for (int i = 0, n = this->strings_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBytesToArray(9, this->strings(i), target); + } + + // repeated .opencv_onnx.TensorProto tensors = 10; + for (unsigned int i = 0, + n = static_cast(this->tensors_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 10, this->tensors(static_cast(i)), deterministic, target); + } + + // repeated .opencv_onnx.GraphProto graphs = 11; + for (unsigned int i = 0, + n = static_cast(this->graphs_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 11, this->graphs(static_cast(i)), deterministic, target); + } + + // optional string doc_string = 13; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 13, this->doc_string(), target); + } + + // optional .opencv_onnx.AttributeProto.AttributeType type = 20; + if (cached_has_bits & 0x00000100u) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 20, this->type(), target); + } + + // optional string ref_attr_name = 21; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->ref_attr_name().data(), static_cast(this->ref_attr_name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.AttributeProto.ref_attr_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 21, this->ref_attr_name(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.AttributeProto) + return target; +} + +size_t AttributeProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.AttributeProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated float floats = 7; + { + unsigned int count = static_cast(this->floats_size()); + size_t data_size = 4UL * count; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->floats_size()); + total_size += data_size; + } + + // repeated int64 ints = 8; + { + size_t data_size = ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->ints_); + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->ints_size()); + total_size += data_size; + } + + // repeated bytes strings = 9; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->strings_size()); + for (int i = 0, n = this->strings_size(); i < n; i++) { + total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( + this->strings(i)); + } + + // repeated .opencv_onnx.TensorProto tensors = 10; + { + unsigned int count = static_cast(this->tensors_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->tensors(static_cast(i))); + } + } + + // repeated .opencv_onnx.GraphProto graphs = 11; + { + unsigned int count = static_cast(this->graphs_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->graphs(static_cast(i))); + } + } + + if (_has_bits_[0 / 32] & 255u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional bytes s = 4; + if (has_s()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->s()); + } + + // optional string doc_string = 13; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + // optional string ref_attr_name = 21; + if (has_ref_attr_name()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->ref_attr_name()); + } + + // optional .opencv_onnx.TensorProto t = 5; + if (has_t()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->t_); + } + + // optional .opencv_onnx.GraphProto g = 6; + if (has_g()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->g_); + } + + // optional int64 i = 3; + if (has_i()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->i()); + } + + // optional float f = 2; + if (has_f()) { + total_size += 1 + 4; + } + + } + // optional .opencv_onnx.AttributeProto.AttributeType type = 20; + if (has_type()) { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->type()); + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AttributeProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.AttributeProto) + GOOGLE_DCHECK_NE(&from, this); + const AttributeProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.AttributeProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.AttributeProto) + MergeFrom(*source); + } +} + +void AttributeProto::MergeFrom(const AttributeProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.AttributeProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + floats_.MergeFrom(from.floats_); + ints_.MergeFrom(from.ints_); + strings_.MergeFrom(from.strings_); + tensors_.MergeFrom(from.tensors_); + graphs_.MergeFrom(from.graphs_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 255u) { + if (cached_has_bits & 0x00000001u) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_s(); + s_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.s_); + } + if (cached_has_bits & 0x00000004u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (cached_has_bits & 0x00000008u) { + set_has_ref_attr_name(); + ref_attr_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.ref_attr_name_); + } + if (cached_has_bits & 0x00000010u) { + mutable_t()->::opencv_onnx::TensorProto::MergeFrom(from.t()); + } + if (cached_has_bits & 0x00000020u) { + mutable_g()->::opencv_onnx::GraphProto::MergeFrom(from.g()); + } + if (cached_has_bits & 0x00000040u) { + i_ = from.i_; + } + if (cached_has_bits & 0x00000080u) { + f_ = from.f_; + } + _has_bits_[0] |= cached_has_bits; + } + if (cached_has_bits & 0x00000100u) { + set_type(from.type()); + } +} + +void AttributeProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.AttributeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AttributeProto::CopyFrom(const AttributeProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.AttributeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AttributeProto::IsInitialized() const { + return true; +} + +void AttributeProto::Swap(AttributeProto* other) { + if (other == this) return; + InternalSwap(other); +} +void AttributeProto::InternalSwap(AttributeProto* other) { + using std::swap; + floats_.InternalSwap(&other->floats_); + ints_.InternalSwap(&other->ints_); + strings_.InternalSwap(&other->strings_); + tensors_.InternalSwap(&other->tensors_); + graphs_.InternalSwap(&other->graphs_); + name_.Swap(&other->name_); + s_.Swap(&other->s_); + doc_string_.Swap(&other->doc_string_); + ref_attr_name_.Swap(&other->ref_attr_name_); + swap(t_, other->t_); + swap(g_, other->g_); + swap(i_, other->i_); + swap(f_, other->f_); + swap(type_, other->type_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata AttributeProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void ValueInfoProto::InitAsDefaultInstance() { + ::opencv_onnx::_ValueInfoProto_default_instance_._instance.get_mutable()->type_ = const_cast< ::opencv_onnx::TypeProto*>( + ::opencv_onnx::TypeProto::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ValueInfoProto::kNameFieldNumber; +const int ValueInfoProto::kTypeFieldNumber; +const int ValueInfoProto::kDocStringFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ValueInfoProto::ValueInfoProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsValueInfoProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.ValueInfoProto) +} +ValueInfoProto::ValueInfoProto(const ValueInfoProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_name()) { + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (from.has_type()) { + type_ = new ::opencv_onnx::TypeProto(*from.type_); + } else { + type_ = NULL; + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.ValueInfoProto) +} + +void ValueInfoProto::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + type_ = NULL; +} + +ValueInfoProto::~ValueInfoProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.ValueInfoProto) + SharedDtor(); +} + +void ValueInfoProto::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete type_; +} + +void ValueInfoProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ValueInfoProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const ValueInfoProto& ValueInfoProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsValueInfoProto(); + return *internal_default_instance(); +} + +ValueInfoProto* ValueInfoProto::New(::google::protobuf::Arena* arena) const { + ValueInfoProto* n = new ValueInfoProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ValueInfoProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.ValueInfoProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 7u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(type_ != NULL); + type_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool ValueInfoProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.ValueInfoProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string name = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ValueInfoProto.name"); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.TypeProto type = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_type())); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ValueInfoProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.ValueInfoProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.ValueInfoProto) + return false; +#undef DO_ +} + +void ValueInfoProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.ValueInfoProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ValueInfoProto.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->name(), output); + } + + // optional .opencv_onnx.TypeProto type = 2; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->type_, output); + } + + // optional string doc_string = 3; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ValueInfoProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->doc_string(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.ValueInfoProto) +} + +::google::protobuf::uint8* ValueInfoProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.ValueInfoProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ValueInfoProto.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // optional .opencv_onnx.TypeProto type = 2; + if (cached_has_bits & 0x00000004u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, *this->type_, deterministic, target); + } + + // optional string doc_string = 3; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ValueInfoProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->doc_string(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.ValueInfoProto) + return target; +} + +size_t ValueInfoProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.ValueInfoProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + if (_has_bits_[0 / 32] & 7u) { + // optional string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string doc_string = 3; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + // optional .opencv_onnx.TypeProto type = 2; + if (has_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->type_); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ValueInfoProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.ValueInfoProto) + GOOGLE_DCHECK_NE(&from, this); + const ValueInfoProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.ValueInfoProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.ValueInfoProto) + MergeFrom(*source); + } +} + +void ValueInfoProto::MergeFrom(const ValueInfoProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.ValueInfoProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 7u) { + if (cached_has_bits & 0x00000001u) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (cached_has_bits & 0x00000004u) { + mutable_type()->::opencv_onnx::TypeProto::MergeFrom(from.type()); + } + } +} + +void ValueInfoProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.ValueInfoProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ValueInfoProto::CopyFrom(const ValueInfoProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.ValueInfoProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ValueInfoProto::IsInitialized() const { + return true; +} + +void ValueInfoProto::Swap(ValueInfoProto* other) { + if (other == this) return; + InternalSwap(other); +} +void ValueInfoProto::InternalSwap(ValueInfoProto* other) { + using std::swap; + name_.Swap(&other->name_); + doc_string_.Swap(&other->doc_string_); + swap(type_, other->type_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ValueInfoProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void NodeProto::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int NodeProto::kInputFieldNumber; +const int NodeProto::kOutputFieldNumber; +const int NodeProto::kNameFieldNumber; +const int NodeProto::kOpTypeFieldNumber; +const int NodeProto::kDomainFieldNumber; +const int NodeProto::kAttributeFieldNumber; +const int NodeProto::kDocStringFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +NodeProto::NodeProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.NodeProto) +} +NodeProto::NodeProto(const NodeProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + input_(from.input_), + output_(from.output_), + attribute_(from.attribute_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_name()) { + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + op_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_op_type()) { + op_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.op_type_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_domain()) { + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.NodeProto) +} + +void NodeProto::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + op_type_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +NodeProto::~NodeProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.NodeProto) + SharedDtor(); +} + +void NodeProto::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + op_type_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + domain_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void NodeProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* NodeProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const NodeProto& NodeProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + return *internal_default_instance(); +} + +NodeProto* NodeProto::New(::google::protobuf::Arena* arena) const { + NodeProto* n = new NodeProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void NodeProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.NodeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + input_.Clear(); + output_.Clear(); + attribute_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 15u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!op_type_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*op_type_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(!domain_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*domain_.UnsafeRawStringPointer())->clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool NodeProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.NodeProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated string input = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_input())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(this->input_size() - 1).data(), + static_cast(this->input(this->input_size() - 1).length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.input"); + } else { + goto handle_unusual; + } + break; + } + + // repeated string output = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->add_output())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output(this->output_size() - 1).data(), + static_cast(this->output(this->output_size() - 1).length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.output"); + } else { + goto handle_unusual; + } + break; + } + + // optional string name = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.name"); + } else { + goto handle_unusual; + } + break; + } + + // optional string op_type = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_op_type())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->op_type().data(), static_cast(this->op_type().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.op_type"); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.AttributeProto attribute = 5; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_attribute())); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + // optional string domain = 7; + case 7: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_domain())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.NodeProto.domain"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.NodeProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.NodeProto) + return false; +#undef DO_ +} + +void NodeProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.NodeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string input = 1; + for (int i = 0, n = this->input_size(); i < n; i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(i).data(), static_cast(this->input(i).length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.input"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->input(i), output); + } + + // repeated string output = 2; + for (int i = 0, n = this->output_size(); i < n; i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output(i).data(), static_cast(this->output(i).length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.output"); + ::google::protobuf::internal::WireFormatLite::WriteString( + 2, this->output(i), output); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->name(), output); + } + + // optional string op_type = 4; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->op_type().data(), static_cast(this->op_type().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.op_type"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->op_type(), output); + } + + // repeated .opencv_onnx.AttributeProto attribute = 5; + for (unsigned int i = 0, + n = static_cast(this->attribute_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->attribute(static_cast(i)), output); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->doc_string(), output); + } + + // optional string domain = 7; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.domain"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 7, this->domain(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.NodeProto) +} + +::google::protobuf::uint8* NodeProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.NodeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string input = 1; + for (int i = 0, n = this->input_size(); i < n; i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->input(i).data(), static_cast(this->input(i).length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.input"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(1, this->input(i), target); + } + + // repeated string output = 2; + for (int i = 0, n = this->output_size(); i < n; i++) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->output(i).data(), static_cast(this->output(i).length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.output"); + target = ::google::protobuf::internal::WireFormatLite:: + WriteStringToArray(2, this->output(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->name(), target); + } + + // optional string op_type = 4; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->op_type().data(), static_cast(this->op_type().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.op_type"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->op_type(), target); + } + + // repeated .opencv_onnx.AttributeProto attribute = 5; + for (unsigned int i = 0, + n = static_cast(this->attribute_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->attribute(static_cast(i)), deterministic, target); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->doc_string(), target); + } + + // optional string domain = 7; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.NodeProto.domain"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 7, this->domain(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.NodeProto) + return target; +} + +size_t NodeProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.NodeProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated string input = 1; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->input_size()); + for (int i = 0, n = this->input_size(); i < n; i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->input(i)); + } + + // repeated string output = 2; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->output_size()); + for (int i = 0, n = this->output_size(); i < n; i++) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this->output(i)); + } + + // repeated .opencv_onnx.AttributeProto attribute = 5; + { + unsigned int count = static_cast(this->attribute_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->attribute(static_cast(i))); + } + } + + if (_has_bits_[0 / 32] & 15u) { + // optional string name = 3; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string op_type = 4; + if (has_op_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->op_type()); + } + + // optional string doc_string = 6; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + // optional string domain = 7; + if (has_domain()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->domain()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void NodeProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.NodeProto) + GOOGLE_DCHECK_NE(&from, this); + const NodeProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.NodeProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.NodeProto) + MergeFrom(*source); + } +} + +void NodeProto::MergeFrom(const NodeProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.NodeProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + input_.MergeFrom(from.input_); + output_.MergeFrom(from.output_); + attribute_.MergeFrom(from.attribute_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 15u) { + if (cached_has_bits & 0x00000001u) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_op_type(); + op_type_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.op_type_); + } + if (cached_has_bits & 0x00000004u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (cached_has_bits & 0x00000008u) { + set_has_domain(); + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + } +} + +void NodeProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.NodeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NodeProto::CopyFrom(const NodeProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.NodeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NodeProto::IsInitialized() const { + return true; +} + +void NodeProto::Swap(NodeProto* other) { + if (other == this) return; + InternalSwap(other); +} +void NodeProto::InternalSwap(NodeProto* other) { + using std::swap; + input_.InternalSwap(&other->input_); + output_.InternalSwap(&other->output_); + attribute_.InternalSwap(&other->attribute_); + name_.Swap(&other->name_); + op_type_.Swap(&other->op_type_); + doc_string_.Swap(&other->doc_string_); + domain_.Swap(&other->domain_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata NodeProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void ModelProto::InitAsDefaultInstance() { + ::opencv_onnx::_ModelProto_default_instance_._instance.get_mutable()->graph_ = const_cast< ::opencv_onnx::GraphProto*>( + ::opencv_onnx::GraphProto::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int ModelProto::kIrVersionFieldNumber; +const int ModelProto::kOpsetImportFieldNumber; +const int ModelProto::kProducerNameFieldNumber; +const int ModelProto::kProducerVersionFieldNumber; +const int ModelProto::kDomainFieldNumber; +const int ModelProto::kModelVersionFieldNumber; +const int ModelProto::kDocStringFieldNumber; +const int ModelProto::kGraphFieldNumber; +const int ModelProto::kMetadataPropsFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +ModelProto::ModelProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsModelProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.ModelProto) +} +ModelProto::ModelProto(const ModelProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + opset_import_(from.opset_import_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + producer_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_producer_name()) { + producer_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.producer_name_); + } + producer_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_producer_version()) { + producer_version_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.producer_version_); + } + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_domain()) { + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (from.has_graph()) { + graph_ = new ::opencv_onnx::GraphProto(*from.graph_); + } else { + graph_ = NULL; + } + ::memcpy(&ir_version_, &from.ir_version_, + static_cast(reinterpret_cast(&model_version_) - + reinterpret_cast(&ir_version_)) + sizeof(model_version_)); + // @@protoc_insertion_point(copy_constructor:opencv_onnx.ModelProto) +} + +void ModelProto::SharedCtor() { + _cached_size_ = 0; + producer_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + producer_version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&graph_, 0, static_cast( + reinterpret_cast(&model_version_) - + reinterpret_cast(&graph_)) + sizeof(model_version_)); +} + +ModelProto::~ModelProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.ModelProto) + SharedDtor(); +} + +void ModelProto::SharedDtor() { + producer_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + producer_version_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + domain_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete graph_; +} + +void ModelProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* ModelProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const ModelProto& ModelProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsModelProto(); + return *internal_default_instance(); +} + +ModelProto* ModelProto::New(::google::protobuf::Arena* arena) const { + ModelProto* n = new ModelProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void ModelProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.ModelProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + opset_import_.Clear(); + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 31u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!producer_name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*producer_name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!producer_version_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*producer_version_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(!domain_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*domain_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(graph_ != NULL); + graph_->Clear(); + } + } + if (cached_has_bits & 96u) { + ::memset(&ir_version_, 0, static_cast( + reinterpret_cast(&model_version_) - + reinterpret_cast(&ir_version_)) + sizeof(model_version_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool ModelProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.ModelProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 ir_version = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + set_has_ir_version(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &ir_version_))); + } else { + goto handle_unusual; + } + break; + } + + // optional string producer_name = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_producer_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_name().data(), static_cast(this->producer_name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ModelProto.producer_name"); + } else { + goto handle_unusual; + } + break; + } + + // optional string producer_version = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_producer_version())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_version().data(), static_cast(this->producer_version().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ModelProto.producer_version"); + } else { + goto handle_unusual; + } + break; + } + + // optional string domain = 4; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_domain())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ModelProto.domain"); + } else { + goto handle_unusual; + } + break; + } + + // optional int64 model_version = 5; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { + set_has_model_version(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &model_version_))); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.ModelProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.GraphProto graph = 7; + case 7: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_graph())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8; + case 8: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_opset_import())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14; + case 14: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(114u /* 114 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_metadata_props())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.ModelProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.ModelProto) + return false; +#undef DO_ +} + +void ModelProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.ModelProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 ir_version = 1; + if (cached_has_bits & 0x00000020u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->ir_version(), output); + } + + // optional string producer_name = 2; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_name().data(), static_cast(this->producer_name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.producer_name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->producer_name(), output); + } + + // optional string producer_version = 3; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_version().data(), static_cast(this->producer_version().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.producer_version"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->producer_version(), output); + } + + // optional string domain = 4; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.domain"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 4, this->domain(), output); + } + + // optional int64 model_version = 5; + if (cached_has_bits & 0x00000040u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(5, this->model_version(), output); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->doc_string(), output); + } + + // optional .opencv_onnx.GraphProto graph = 7; + if (cached_has_bits & 0x00000010u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 7, *this->graph_, output); + } + + // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8; + for (unsigned int i = 0, + n = static_cast(this->opset_import_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 8, this->opset_import(static_cast(i)), output); + } + + // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14; + for (unsigned int i = 0, + n = static_cast(this->metadata_props_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 14, this->metadata_props(static_cast(i)), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.ModelProto) +} + +::google::protobuf::uint8* ModelProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.ModelProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 ir_version = 1; + if (cached_has_bits & 0x00000020u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->ir_version(), target); + } + + // optional string producer_name = 2; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_name().data(), static_cast(this->producer_name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.producer_name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->producer_name(), target); + } + + // optional string producer_version = 3; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->producer_version().data(), static_cast(this->producer_version().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.producer_version"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->producer_version(), target); + } + + // optional string domain = 4; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.domain"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 4, this->domain(), target); + } + + // optional int64 model_version = 5; + if (cached_has_bits & 0x00000040u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(5, this->model_version(), target); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.ModelProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->doc_string(), target); + } + + // optional .opencv_onnx.GraphProto graph = 7; + if (cached_has_bits & 0x00000010u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 7, *this->graph_, deterministic, target); + } + + // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8; + for (unsigned int i = 0, + n = static_cast(this->opset_import_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 8, this->opset_import(static_cast(i)), deterministic, target); + } + + // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14; + for (unsigned int i = 0, + n = static_cast(this->metadata_props_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 14, this->metadata_props(static_cast(i)), deterministic, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.ModelProto) + return target; +} + +size_t ModelProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.ModelProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated .opencv_onnx.OperatorSetIdProto opset_import = 8; + { + unsigned int count = static_cast(this->opset_import_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->opset_import(static_cast(i))); + } + } + + // repeated .opencv_onnx.StringStringEntryProto metadata_props = 14; + { + unsigned int count = static_cast(this->metadata_props_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->metadata_props(static_cast(i))); + } + } + + if (_has_bits_[0 / 32] & 127u) { + // optional string producer_name = 2; + if (has_producer_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->producer_name()); + } + + // optional string producer_version = 3; + if (has_producer_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->producer_version()); + } + + // optional string domain = 4; + if (has_domain()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->domain()); + } + + // optional string doc_string = 6; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + // optional .opencv_onnx.GraphProto graph = 7; + if (has_graph()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->graph_); + } + + // optional int64 ir_version = 1; + if (has_ir_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->ir_version()); + } + + // optional int64 model_version = 5; + if (has_model_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->model_version()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ModelProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.ModelProto) + GOOGLE_DCHECK_NE(&from, this); + const ModelProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.ModelProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.ModelProto) + MergeFrom(*source); + } +} + +void ModelProto::MergeFrom(const ModelProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.ModelProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + opset_import_.MergeFrom(from.opset_import_); + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 127u) { + if (cached_has_bits & 0x00000001u) { + set_has_producer_name(); + producer_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.producer_name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_producer_version(); + producer_version_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.producer_version_); + } + if (cached_has_bits & 0x00000004u) { + set_has_domain(); + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + if (cached_has_bits & 0x00000008u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (cached_has_bits & 0x00000010u) { + mutable_graph()->::opencv_onnx::GraphProto::MergeFrom(from.graph()); + } + if (cached_has_bits & 0x00000020u) { + ir_version_ = from.ir_version_; + } + if (cached_has_bits & 0x00000040u) { + model_version_ = from.model_version_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void ModelProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.ModelProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ModelProto::CopyFrom(const ModelProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.ModelProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ModelProto::IsInitialized() const { + return true; +} + +void ModelProto::Swap(ModelProto* other) { + if (other == this) return; + InternalSwap(other); +} +void ModelProto::InternalSwap(ModelProto* other) { + using std::swap; + opset_import_.InternalSwap(&other->opset_import_); + metadata_props_.InternalSwap(&other->metadata_props_); + producer_name_.Swap(&other->producer_name_); + producer_version_.Swap(&other->producer_version_); + domain_.Swap(&other->domain_); + doc_string_.Swap(&other->doc_string_); + swap(graph_, other->graph_); + swap(ir_version_, other->ir_version_); + swap(model_version_, other->model_version_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata ModelProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void StringStringEntryProto::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int StringStringEntryProto::kKeyFieldNumber; +const int StringStringEntryProto::kValueFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +StringStringEntryProto::StringStringEntryProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsStringStringEntryProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.StringStringEntryProto) +} +StringStringEntryProto::StringStringEntryProto(const StringStringEntryProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_key()) { + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_value()) { + value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_); + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.StringStringEntryProto) +} + +void StringStringEntryProto::SharedCtor() { + _cached_size_ = 0; + key_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +StringStringEntryProto::~StringStringEntryProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.StringStringEntryProto) + SharedDtor(); +} + +void StringStringEntryProto::SharedDtor() { + key_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void StringStringEntryProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* StringStringEntryProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const StringStringEntryProto& StringStringEntryProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsStringStringEntryProto(); + return *internal_default_instance(); +} + +StringStringEntryProto* StringStringEntryProto::New(::google::protobuf::Arena* arena) const { + StringStringEntryProto* n = new StringStringEntryProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void StringStringEntryProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.StringStringEntryProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!key_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*key_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!value_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*value_.UnsafeRawStringPointer())->clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool StringStringEntryProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.StringStringEntryProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string key = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_key())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->key().data(), static_cast(this->key().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.StringStringEntryProto.key"); + } else { + goto handle_unusual; + } + break; + } + + // optional string value = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_value())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->value().data(), static_cast(this->value().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.StringStringEntryProto.value"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.StringStringEntryProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.StringStringEntryProto) + return false; +#undef DO_ +} + +void StringStringEntryProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.StringStringEntryProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string key = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->key().data(), static_cast(this->key().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.StringStringEntryProto.key"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->key(), output); + } + + // optional string value = 2; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->value().data(), static_cast(this->value().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.StringStringEntryProto.value"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->value(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.StringStringEntryProto) +} + +::google::protobuf::uint8* StringStringEntryProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.StringStringEntryProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string key = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->key().data(), static_cast(this->key().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.StringStringEntryProto.key"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->key(), target); + } + + // optional string value = 2; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->value().data(), static_cast(this->value().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.StringStringEntryProto.value"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->value(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.StringStringEntryProto) + return target; +} + +size_t StringStringEntryProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.StringStringEntryProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + if (_has_bits_[0 / 32] & 3u) { + // optional string key = 1; + if (has_key()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->key()); + } + + // optional string value = 2; + if (has_value()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->value()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void StringStringEntryProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.StringStringEntryProto) + GOOGLE_DCHECK_NE(&from, this); + const StringStringEntryProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.StringStringEntryProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.StringStringEntryProto) + MergeFrom(*source); + } +} + +void StringStringEntryProto::MergeFrom(const StringStringEntryProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.StringStringEntryProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + set_has_key(); + key_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.key_); + } + if (cached_has_bits & 0x00000002u) { + set_has_value(); + value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_); + } + } +} + +void StringStringEntryProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.StringStringEntryProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void StringStringEntryProto::CopyFrom(const StringStringEntryProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.StringStringEntryProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool StringStringEntryProto::IsInitialized() const { + return true; +} + +void StringStringEntryProto::Swap(StringStringEntryProto* other) { + if (other == this) return; + InternalSwap(other); +} +void StringStringEntryProto::InternalSwap(StringStringEntryProto* other) { + using std::swap; + key_.Swap(&other->key_); + value_.Swap(&other->value_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata StringStringEntryProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void GraphProto::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int GraphProto::kNodeFieldNumber; +const int GraphProto::kNameFieldNumber; +const int GraphProto::kInitializerFieldNumber; +const int GraphProto::kDocStringFieldNumber; +const int GraphProto::kInputFieldNumber; +const int GraphProto::kOutputFieldNumber; +const int GraphProto::kValueInfoFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +GraphProto::GraphProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.GraphProto) +} +GraphProto::GraphProto(const GraphProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + node_(from.node_), + initializer_(from.initializer_), + input_(from.input_), + output_(from.output_), + value_info_(from.value_info_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_name()) { + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.GraphProto) +} + +void GraphProto::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +GraphProto::~GraphProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.GraphProto) + SharedDtor(); +} + +void GraphProto::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void GraphProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* GraphProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const GraphProto& GraphProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsAttributeProto(); + return *internal_default_instance(); +} + +GraphProto* GraphProto::New(::google::protobuf::Arena* arena) const { + GraphProto* n = new GraphProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void GraphProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.GraphProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + node_.Clear(); + initializer_.Clear(); + input_.Clear(); + output_.Clear(); + value_info_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool GraphProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.GraphProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .opencv_onnx.NodeProto node = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_node())); + } else { + goto handle_unusual; + } + break; + } + + // optional string name = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.GraphProto.name"); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.TensorProto initializer = 5; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_initializer())); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 10; + case 10: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.GraphProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.ValueInfoProto input = 11; + case 11: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_input())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.ValueInfoProto output = 12; + case 12: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_output())); + } else { + goto handle_unusual; + } + break; + } + + // repeated .opencv_onnx.ValueInfoProto value_info = 13; + case 13: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_value_info())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.GraphProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.GraphProto) + return false; +#undef DO_ +} + +void GraphProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.GraphProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_onnx.NodeProto node = 1; + for (unsigned int i = 0, + n = static_cast(this->node_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->node(static_cast(i)), output); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.GraphProto.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->name(), output); + } + + // repeated .opencv_onnx.TensorProto initializer = 5; + for (unsigned int i = 0, + n = static_cast(this->initializer_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->initializer(static_cast(i)), output); + } + + // optional string doc_string = 10; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.GraphProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 10, this->doc_string(), output); + } + + // repeated .opencv_onnx.ValueInfoProto input = 11; + for (unsigned int i = 0, + n = static_cast(this->input_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 11, this->input(static_cast(i)), output); + } + + // repeated .opencv_onnx.ValueInfoProto output = 12; + for (unsigned int i = 0, + n = static_cast(this->output_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 12, this->output(static_cast(i)), output); + } + + // repeated .opencv_onnx.ValueInfoProto value_info = 13; + for (unsigned int i = 0, + n = static_cast(this->value_info_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 13, this->value_info(static_cast(i)), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.GraphProto) +} + +::google::protobuf::uint8* GraphProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.GraphProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_onnx.NodeProto node = 1; + for (unsigned int i = 0, + n = static_cast(this->node_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->node(static_cast(i)), deterministic, target); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.GraphProto.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->name(), target); + } + + // repeated .opencv_onnx.TensorProto initializer = 5; + for (unsigned int i = 0, + n = static_cast(this->initializer_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 5, this->initializer(static_cast(i)), deterministic, target); + } + + // optional string doc_string = 10; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.GraphProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 10, this->doc_string(), target); + } + + // repeated .opencv_onnx.ValueInfoProto input = 11; + for (unsigned int i = 0, + n = static_cast(this->input_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 11, this->input(static_cast(i)), deterministic, target); + } + + // repeated .opencv_onnx.ValueInfoProto output = 12; + for (unsigned int i = 0, + n = static_cast(this->output_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 12, this->output(static_cast(i)), deterministic, target); + } + + // repeated .opencv_onnx.ValueInfoProto value_info = 13; + for (unsigned int i = 0, + n = static_cast(this->value_info_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 13, this->value_info(static_cast(i)), deterministic, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.GraphProto) + return target; +} + +size_t GraphProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.GraphProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated .opencv_onnx.NodeProto node = 1; + { + unsigned int count = static_cast(this->node_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->node(static_cast(i))); + } + } + + // repeated .opencv_onnx.TensorProto initializer = 5; + { + unsigned int count = static_cast(this->initializer_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->initializer(static_cast(i))); + } + } + + // repeated .opencv_onnx.ValueInfoProto input = 11; + { + unsigned int count = static_cast(this->input_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->input(static_cast(i))); + } + } + + // repeated .opencv_onnx.ValueInfoProto output = 12; + { + unsigned int count = static_cast(this->output_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->output(static_cast(i))); + } + } + + // repeated .opencv_onnx.ValueInfoProto value_info = 13; + { + unsigned int count = static_cast(this->value_info_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->value_info(static_cast(i))); + } + } + + if (_has_bits_[0 / 32] & 3u) { + // optional string name = 2; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional string doc_string = 10; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void GraphProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.GraphProto) + GOOGLE_DCHECK_NE(&from, this); + const GraphProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.GraphProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.GraphProto) + MergeFrom(*source); + } +} + +void GraphProto::MergeFrom(const GraphProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.GraphProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + node_.MergeFrom(from.node_); + initializer_.MergeFrom(from.initializer_); + input_.MergeFrom(from.input_); + output_.MergeFrom(from.output_); + value_info_.MergeFrom(from.value_info_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + } +} + +void GraphProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.GraphProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void GraphProto::CopyFrom(const GraphProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.GraphProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool GraphProto::IsInitialized() const { + return true; +} + +void GraphProto::Swap(GraphProto* other) { + if (other == this) return; + InternalSwap(other); +} +void GraphProto::InternalSwap(GraphProto* other) { + using std::swap; + node_.InternalSwap(&other->node_); + initializer_.InternalSwap(&other->initializer_); + input_.InternalSwap(&other->input_); + output_.InternalSwap(&other->output_); + value_info_.InternalSwap(&other->value_info_); + name_.Swap(&other->name_); + doc_string_.Swap(&other->doc_string_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata GraphProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TensorProto_Segment::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorProto_Segment::kBeginFieldNumber; +const int TensorProto_Segment::kEndFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorProto_Segment::TensorProto_Segment() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto_Segment(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TensorProto.Segment) +} +TensorProto_Segment::TensorProto_Segment(const TensorProto_Segment& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::memcpy(&begin_, &from.begin_, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&begin_)) + sizeof(end_)); + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TensorProto.Segment) +} + +void TensorProto_Segment::SharedCtor() { + _cached_size_ = 0; + ::memset(&begin_, 0, static_cast( + reinterpret_cast(&end_) - + reinterpret_cast(&begin_)) + sizeof(end_)); +} + +TensorProto_Segment::~TensorProto_Segment() { + // @@protoc_insertion_point(destructor:opencv_onnx.TensorProto.Segment) + SharedDtor(); +} + +void TensorProto_Segment::SharedDtor() { +} + +void TensorProto_Segment::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorProto_Segment::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TensorProto_Segment& TensorProto_Segment::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto_Segment(); + return *internal_default_instance(); +} + +TensorProto_Segment* TensorProto_Segment::New(::google::protobuf::Arena* arena) const { + TensorProto_Segment* n = new TensorProto_Segment; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TensorProto_Segment::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TensorProto.Segment) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 3u) { + ::memset(&begin_, 0, static_cast( + reinterpret_cast(&end_) - + reinterpret_cast(&begin_)) + sizeof(end_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TensorProto_Segment::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TensorProto.Segment) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 begin = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + set_has_begin(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &begin_))); + } else { + goto handle_unusual; + } + break; + } + + // optional int64 end = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + set_has_end(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &end_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TensorProto.Segment) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TensorProto.Segment) + return false; +#undef DO_ +} + +void TensorProto_Segment::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TensorProto.Segment) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 begin = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->begin(), output); + } + + // optional int64 end = 2; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->end(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TensorProto.Segment) +} + +::google::protobuf::uint8* TensorProto_Segment::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TensorProto.Segment) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 begin = 1; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->begin(), target); + } + + // optional int64 end = 2; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->end(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TensorProto.Segment) + return target; +} + +size_t TensorProto_Segment::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TensorProto.Segment) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + if (_has_bits_[0 / 32] & 3u) { + // optional int64 begin = 1; + if (has_begin()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->begin()); + } + + // optional int64 end = 2; + if (has_end()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->end()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorProto_Segment::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TensorProto.Segment) + GOOGLE_DCHECK_NE(&from, this); + const TensorProto_Segment* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TensorProto.Segment) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TensorProto.Segment) + MergeFrom(*source); + } +} + +void TensorProto_Segment::MergeFrom(const TensorProto_Segment& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TensorProto.Segment) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + begin_ = from.begin_; + } + if (cached_has_bits & 0x00000002u) { + end_ = from.end_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void TensorProto_Segment::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TensorProto.Segment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorProto_Segment::CopyFrom(const TensorProto_Segment& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TensorProto.Segment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TensorProto_Segment::IsInitialized() const { + return true; +} + +void TensorProto_Segment::Swap(TensorProto_Segment* other) { + if (other == this) return; + InternalSwap(other); +} +void TensorProto_Segment::InternalSwap(TensorProto_Segment* other) { + using std::swap; + swap(begin_, other->begin_); + swap(end_, other->end_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorProto_Segment::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TensorProto::InitAsDefaultInstance() { + ::opencv_onnx::_TensorProto_default_instance_._instance.get_mutable()->segment_ = const_cast< ::opencv_onnx::TensorProto_Segment*>( + ::opencv_onnx::TensorProto_Segment::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorProto::kDimsFieldNumber; +const int TensorProto::kDataTypeFieldNumber; +const int TensorProto::kSegmentFieldNumber; +const int TensorProto::kFloatDataFieldNumber; +const int TensorProto::kInt32DataFieldNumber; +const int TensorProto::kStringDataFieldNumber; +const int TensorProto::kInt64DataFieldNumber; +const int TensorProto::kNameFieldNumber; +const int TensorProto::kDocStringFieldNumber; +const int TensorProto::kRawDataFieldNumber; +const int TensorProto::kDoubleDataFieldNumber; +const int TensorProto::kUint64DataFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorProto::TensorProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TensorProto) +} +TensorProto::TensorProto(const TensorProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + dims_(from.dims_), + float_data_(from.float_data_), + int32_data_(from.int32_data_), + string_data_(from.string_data_), + int64_data_(from.int64_data_), + double_data_(from.double_data_), + uint64_data_(from.uint64_data_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_name()) { + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_raw_data()) { + raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_); + } + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_doc_string()) { + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (from.has_segment()) { + segment_ = new ::opencv_onnx::TensorProto_Segment(*from.segment_); + } else { + segment_ = NULL; + } + data_type_ = from.data_type_; + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TensorProto) +} + +void TensorProto::SharedCtor() { + _cached_size_ = 0; + name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + raw_data_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + ::memset(&segment_, 0, static_cast( + reinterpret_cast(&data_type_) - + reinterpret_cast(&segment_)) + sizeof(data_type_)); +} + +TensorProto::~TensorProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.TensorProto) + SharedDtor(); +} + +void TensorProto::SharedDtor() { + name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + raw_data_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + doc_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete segment_; +} + +void TensorProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TensorProto& TensorProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorProto(); + return *internal_default_instance(); +} + +TensorProto* TensorProto::New(::google::protobuf::Arena* arena) const { + TensorProto* n = new TensorProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TensorProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TensorProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dims_.Clear(); + float_data_.Clear(); + int32_data_.Clear(); + string_data_.Clear(); + int64_data_.Clear(); + double_data_.Clear(); + uint64_data_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 15u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!name_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*name_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(!raw_data_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*raw_data_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(!doc_string_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*doc_string_.UnsafeRawStringPointer())->clear(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(segment_ != NULL); + segment_->Clear(); + } + } + data_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TensorProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TensorProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated int64 dims = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 8u, input, this->mutable_dims()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_dims()))); + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.TensorProto.DataType data_type = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::opencv_onnx::TensorProto_DataType_IsValid(value)) { + set_data_type(static_cast< ::opencv_onnx::TensorProto_DataType >(value)); + } else { + mutable_unknown_fields()->AddVarint( + 2, static_cast< ::google::protobuf::uint64>(value)); + } + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.TensorProto.Segment segment = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_segment())); + } else { + goto handle_unusual; + } + break; + } + + // repeated float float_data = 4 [packed = true]; + case 4: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + input, this->mutable_float_data()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( + 1, 34u, input, this->mutable_float_data()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated int32 int32_data = 5 [packed = true]; + case 5: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, this->mutable_int32_data()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + 1, 42u, input, this->mutable_int32_data()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated bytes string_data = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->add_string_data())); + } else { + goto handle_unusual; + } + break; + } + + // repeated int64 int64_data = 7 [packed = true]; + case 7: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, this->mutable_int64_data()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + 1, 58u, input, this->mutable_int64_data()))); + } else { + goto handle_unusual; + } + break; + } + + // optional string name = 8; + case 8: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.TensorProto.name"); + } else { + goto handle_unusual; + } + break; + } + + // optional bytes raw_data = 9; + case 9: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( + input, this->mutable_raw_data())); + } else { + goto handle_unusual; + } + break; + } + + // repeated double double_data = 10 [packed = true]; + case 10: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_double_data()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(81u /* 81 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 82u, input, this->mutable_double_data()))); + } else { + goto handle_unusual; + } + break; + } + + // repeated uint64 uint64_data = 11 [packed = true]; + case 11: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(90u /* 90 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + input, this->mutable_uint64_data()))); + } else if ( + static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) { + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline< + ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( + 1, 90u, input, this->mutable_uint64_data()))); + } else { + goto handle_unusual; + } + break; + } + + // optional string doc_string = 12; + case 12: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_doc_string())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.TensorProto.doc_string"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TensorProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TensorProto) + return false; +#undef DO_ +} + +void TensorProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TensorProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int64 dims = 1; + for (int i = 0, n = this->dims_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64( + 1, this->dims(i), output); + } + + cached_has_bits = _has_bits_[0]; + // optional .opencv_onnx.TensorProto.DataType data_type = 2; + if (cached_has_bits & 0x00000010u) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 2, this->data_type(), output); + } + + // optional .opencv_onnx.TensorProto.Segment segment = 3; + if (cached_has_bits & 0x00000008u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 3, *this->segment_, output); + } + + // repeated float float_data = 4 [packed = true]; + if (this->float_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(static_cast< ::google::protobuf::uint32>( + _float_data_cached_byte_size_)); + ::google::protobuf::internal::WireFormatLite::WriteFloatArray( + this->float_data().data(), this->float_data_size(), output); + } + + // repeated int32 int32_data = 5 [packed = true]; + if (this->int32_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(static_cast< ::google::protobuf::uint32>( + _int32_data_cached_byte_size_)); + } + for (int i = 0, n = this->int32_data_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag( + this->int32_data(i), output); + } + + // repeated bytes string_data = 6; + for (int i = 0, n = this->string_data_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteBytes( + 6, this->string_data(i), output); + } + + // repeated int64 int64_data = 7 [packed = true]; + if (this->int64_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(static_cast< ::google::protobuf::uint32>( + _int64_data_cached_byte_size_)); + } + for (int i = 0, n = this->int64_data_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag( + this->int64_data(i), output); + } + + // optional string name = 8; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorProto.name"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 8, this->name(), output); + } + + // optional bytes raw_data = 9; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( + 9, this->raw_data(), output); + } + + // repeated double double_data = 10 [packed = true]; + if (this->double_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(static_cast< ::google::protobuf::uint32>( + _double_data_cached_byte_size_)); + ::google::protobuf::internal::WireFormatLite::WriteDoubleArray( + this->double_data().data(), this->double_data_size(), output); + } + + // repeated uint64 uint64_data = 11 [packed = true]; + if (this->uint64_data_size() > 0) { + ::google::protobuf::internal::WireFormatLite::WriteTag(11, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output); + output->WriteVarint32(static_cast< ::google::protobuf::uint32>( + _uint64_data_cached_byte_size_)); + } + for (int i = 0, n = this->uint64_data_size(); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteUInt64NoTag( + this->uint64_data(i), output); + } + + // optional string doc_string = 12; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorProto.doc_string"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 12, this->doc_string(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TensorProto) +} + +::google::protobuf::uint8* TensorProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TensorProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int64 dims = 1; + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64ToArray(1, this->dims_, target); + + cached_has_bits = _has_bits_[0]; + // optional .opencv_onnx.TensorProto.DataType data_type = 2; + if (cached_has_bits & 0x00000010u) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 2, this->data_type(), target); + } + + // optional .opencv_onnx.TensorProto.Segment segment = 3; + if (cached_has_bits & 0x00000008u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 3, *this->segment_, deterministic, target); + } + + // repeated float float_data = 4 [packed = true]; + if (this->float_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 4, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + static_cast< ::google::protobuf::int32>( + _float_data_cached_byte_size_), target); + target = ::google::protobuf::internal::WireFormatLite:: + WriteFloatNoTagToArray(this->float_data_, target); + } + + // repeated int32 int32_data = 5 [packed = true]; + if (this->int32_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 5, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + static_cast< ::google::protobuf::int32>( + _int32_data_cached_byte_size_), target); + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt32NoTagToArray(this->int32_data_, target); + } + + // repeated bytes string_data = 6; + for (int i = 0, n = this->string_data_size(); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteBytesToArray(6, this->string_data(i), target); + } + + // repeated int64 int64_data = 7 [packed = true]; + if (this->int64_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 7, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + static_cast< ::google::protobuf::int32>( + _int64_data_cached_byte_size_), target); + target = ::google::protobuf::internal::WireFormatLite:: + WriteInt64NoTagToArray(this->int64_data_, target); + } + + // optional string name = 8; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->name().data(), static_cast(this->name().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorProto.name"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 8, this->name(), target); + } + + // optional bytes raw_data = 9; + if (cached_has_bits & 0x00000002u) { + target = + ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( + 9, this->raw_data(), target); + } + + // repeated double double_data = 10 [packed = true]; + if (this->double_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 10, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + static_cast< ::google::protobuf::int32>( + _double_data_cached_byte_size_), target); + target = ::google::protobuf::internal::WireFormatLite:: + WriteDoubleNoTagToArray(this->double_data_, target); + } + + // repeated uint64 uint64_data = 11 [packed = true]; + if (this->uint64_data_size() > 0) { + target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray( + 11, + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, + target); + target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray( + static_cast< ::google::protobuf::int32>( + _uint64_data_cached_byte_size_), target); + target = ::google::protobuf::internal::WireFormatLite:: + WriteUInt64NoTagToArray(this->uint64_data_, target); + } + + // optional string doc_string = 12; + if (cached_has_bits & 0x00000004u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->doc_string().data(), static_cast(this->doc_string().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorProto.doc_string"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 12, this->doc_string(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TensorProto) + return target; +} + +size_t TensorProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TensorProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated int64 dims = 1; + { + size_t data_size = ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->dims_); + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->dims_size()); + total_size += data_size; + } + + // repeated float float_data = 4 [packed = true]; + { + unsigned int count = static_cast(this->float_data_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + static_cast< ::google::protobuf::int32>(data_size)); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _float_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated int32 int32_data = 5 [packed = true]; + { + size_t data_size = ::google::protobuf::internal::WireFormatLite:: + Int32Size(this->int32_data_); + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + static_cast< ::google::protobuf::int32>(data_size)); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _int32_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated bytes string_data = 6; + total_size += 1 * + ::google::protobuf::internal::FromIntSize(this->string_data_size()); + for (int i = 0, n = this->string_data_size(); i < n; i++) { + total_size += ::google::protobuf::internal::WireFormatLite::BytesSize( + this->string_data(i)); + } + + // repeated int64 int64_data = 7 [packed = true]; + { + size_t data_size = ::google::protobuf::internal::WireFormatLite:: + Int64Size(this->int64_data_); + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + static_cast< ::google::protobuf::int32>(data_size)); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _int64_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated double double_data = 10 [packed = true]; + { + unsigned int count = static_cast(this->double_data_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + static_cast< ::google::protobuf::int32>(data_size)); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _double_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + // repeated uint64 uint64_data = 11 [packed = true]; + { + size_t data_size = ::google::protobuf::internal::WireFormatLite:: + UInt64Size(this->uint64_data_); + if (data_size > 0) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + static_cast< ::google::protobuf::int32>(data_size)); + } + int cached_size = ::google::protobuf::internal::ToCachedSize(data_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _uint64_data_cached_byte_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + total_size += data_size; + } + + if (_has_bits_[0 / 32] & 31u) { + // optional string name = 8; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + // optional bytes raw_data = 9; + if (has_raw_data()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::BytesSize( + this->raw_data()); + } + + // optional string doc_string = 12; + if (has_doc_string()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->doc_string()); + } + + // optional .opencv_onnx.TensorProto.Segment segment = 3; + if (has_segment()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->segment_); + } + + // optional .opencv_onnx.TensorProto.DataType data_type = 2; + if (has_data_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->data_type()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TensorProto) + GOOGLE_DCHECK_NE(&from, this); + const TensorProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TensorProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TensorProto) + MergeFrom(*source); + } +} + +void TensorProto::MergeFrom(const TensorProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TensorProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + dims_.MergeFrom(from.dims_); + float_data_.MergeFrom(from.float_data_); + int32_data_.MergeFrom(from.int32_data_); + string_data_.MergeFrom(from.string_data_); + int64_data_.MergeFrom(from.int64_data_); + double_data_.MergeFrom(from.double_data_); + uint64_data_.MergeFrom(from.uint64_data_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 31u) { + if (cached_has_bits & 0x00000001u) { + set_has_name(); + name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); + } + if (cached_has_bits & 0x00000002u) { + set_has_raw_data(); + raw_data_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.raw_data_); + } + if (cached_has_bits & 0x00000004u) { + set_has_doc_string(); + doc_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.doc_string_); + } + if (cached_has_bits & 0x00000008u) { + mutable_segment()->::opencv_onnx::TensorProto_Segment::MergeFrom(from.segment()); + } + if (cached_has_bits & 0x00000010u) { + data_type_ = from.data_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void TensorProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TensorProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorProto::CopyFrom(const TensorProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TensorProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TensorProto::IsInitialized() const { + return true; +} + +void TensorProto::Swap(TensorProto* other) { + if (other == this) return; + InternalSwap(other); +} +void TensorProto::InternalSwap(TensorProto* other) { + using std::swap; + dims_.InternalSwap(&other->dims_); + float_data_.InternalSwap(&other->float_data_); + int32_data_.InternalSwap(&other->int32_data_); + string_data_.InternalSwap(&other->string_data_); + int64_data_.InternalSwap(&other->int64_data_); + double_data_.InternalSwap(&other->double_data_); + uint64_data_.InternalSwap(&other->uint64_data_); + name_.Swap(&other->name_); + raw_data_.Swap(&other->raw_data_); + doc_string_.Swap(&other->doc_string_); + swap(segment_, other->segment_); + swap(data_type_, other->data_type_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TensorShapeProto_Dimension::InitAsDefaultInstance() { + ::opencv_onnx::_TensorShapeProto_Dimension_default_instance_.dim_value_ = GOOGLE_LONGLONG(0); + ::opencv_onnx::_TensorShapeProto_Dimension_default_instance_.dim_param_.UnsafeSetDefault( + &::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorShapeProto_Dimension::kDimValueFieldNumber; +const int TensorShapeProto_Dimension::kDimParamFieldNumber; +const int TensorShapeProto_Dimension::kDenotationFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorShapeProto_Dimension::TensorShapeProto_Dimension() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto_Dimension(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TensorShapeProto.Dimension) +} +TensorShapeProto_Dimension::TensorShapeProto_Dimension(const TensorShapeProto_Dimension& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + denotation_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_denotation()) { + denotation_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.denotation_); + } + clear_has_value(); + switch (from.value_case()) { + case kDimValue: { + set_dim_value(from.dim_value()); + break; + } + case kDimParam: { + set_dim_param(from.dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TensorShapeProto.Dimension) +} + +void TensorShapeProto_Dimension::SharedCtor() { + _cached_size_ = 0; + denotation_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_value(); +} + +TensorShapeProto_Dimension::~TensorShapeProto_Dimension() { + // @@protoc_insertion_point(destructor:opencv_onnx.TensorShapeProto.Dimension) + SharedDtor(); +} + +void TensorShapeProto_Dimension::SharedDtor() { + denotation_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (has_value()) { + clear_value(); + } +} + +void TensorShapeProto_Dimension::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorShapeProto_Dimension::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TensorShapeProto_Dimension& TensorShapeProto_Dimension::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto_Dimension(); + return *internal_default_instance(); +} + +TensorShapeProto_Dimension* TensorShapeProto_Dimension::New(::google::protobuf::Arena* arena) const { + TensorShapeProto_Dimension* n = new TensorShapeProto_Dimension; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TensorShapeProto_Dimension::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:opencv_onnx.TensorShapeProto.Dimension) + switch (value_case()) { + case kDimValue: { + // No need to clear + break; + } + case kDimParam: { + value_.dim_param_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void TensorShapeProto_Dimension::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TensorShapeProto.Dimension) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!denotation_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*denotation_.UnsafeRawStringPointer())->clear(); + } + clear_value(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TensorShapeProto_Dimension::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TensorShapeProto.Dimension) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional int64 dim_value = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + clear_value(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &value_.dim_value_))); + set_has_dim_value(); + } else { + goto handle_unusual; + } + break; + } + + // optional string dim_param = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_dim_param())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->dim_param().data(), static_cast(this->dim_param().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.TensorShapeProto.Dimension.dim_param"); + } else { + goto handle_unusual; + } + break; + } + + // optional string denotation = 3; + case 3: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_denotation())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.TensorShapeProto.Dimension.denotation"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TensorShapeProto.Dimension) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TensorShapeProto.Dimension) + return false; +#undef DO_ +} + +void TensorShapeProto_Dimension::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TensorShapeProto.Dimension) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (value_case()) { + case kDimValue: + ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->dim_value(), output); + break; + case kDimParam: + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->dim_param().data(), static_cast(this->dim_param().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorShapeProto.Dimension.dim_param"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 2, this->dim_param(), output); + break; + default: ; + } + cached_has_bits = _has_bits_[0]; + // optional string denotation = 3; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorShapeProto.Dimension.denotation"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 3, this->denotation(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TensorShapeProto.Dimension) +} + +::google::protobuf::uint8* TensorShapeProto_Dimension::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TensorShapeProto.Dimension) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (value_case()) { + case kDimValue: + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1, this->dim_value(), target); + break; + case kDimParam: + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->dim_param().data(), static_cast(this->dim_param().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorShapeProto.Dimension.dim_param"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 2, this->dim_param(), target); + break; + default: ; + } + cached_has_bits = _has_bits_[0]; + // optional string denotation = 3; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TensorShapeProto.Dimension.denotation"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 3, this->denotation(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TensorShapeProto.Dimension) + return target; +} + +size_t TensorShapeProto_Dimension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TensorShapeProto.Dimension) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // optional string denotation = 3; + if (has_denotation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->denotation()); + } + + switch (value_case()) { + // optional int64 dim_value = 1; + case kDimValue: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->dim_value()); + break; + } + // optional string dim_param = 2; + case kDimParam: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorShapeProto_Dimension::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TensorShapeProto.Dimension) + GOOGLE_DCHECK_NE(&from, this); + const TensorShapeProto_Dimension* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TensorShapeProto.Dimension) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TensorShapeProto.Dimension) + MergeFrom(*source); + } +} + +void TensorShapeProto_Dimension::MergeFrom(const TensorShapeProto_Dimension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TensorShapeProto.Dimension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_denotation()) { + set_has_denotation(); + denotation_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.denotation_); + } + switch (from.value_case()) { + case kDimValue: { + set_dim_value(from.dim_value()); + break; + } + case kDimParam: { + set_dim_param(from.dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void TensorShapeProto_Dimension::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TensorShapeProto.Dimension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorShapeProto_Dimension::CopyFrom(const TensorShapeProto_Dimension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TensorShapeProto.Dimension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TensorShapeProto_Dimension::IsInitialized() const { + return true; +} + +void TensorShapeProto_Dimension::Swap(TensorShapeProto_Dimension* other) { + if (other == this) return; + InternalSwap(other); +} +void TensorShapeProto_Dimension::InternalSwap(TensorShapeProto_Dimension* other) { + using std::swap; + denotation_.Swap(&other->denotation_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorShapeProto_Dimension::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TensorShapeProto::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TensorShapeProto::kDimFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TensorShapeProto::TensorShapeProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TensorShapeProto) +} +TensorShapeProto::TensorShapeProto(const TensorShapeProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0), + dim_(from.dim_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TensorShapeProto) +} + +void TensorShapeProto::SharedCtor() { + _cached_size_ = 0; +} + +TensorShapeProto::~TensorShapeProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.TensorShapeProto) + SharedDtor(); +} + +void TensorShapeProto::SharedDtor() { +} + +void TensorShapeProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TensorShapeProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TensorShapeProto& TensorShapeProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTensorShapeProto(); + return *internal_default_instance(); +} + +TensorShapeProto* TensorShapeProto::New(::google::protobuf::Arena* arena) const { + TensorShapeProto* n = new TensorShapeProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TensorShapeProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TensorShapeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + dim_.Clear(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TensorShapeProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TensorShapeProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_dim())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TensorShapeProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TensorShapeProto) + return false; +#undef DO_ +} + +void TensorShapeProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TensorShapeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1; + for (unsigned int i = 0, + n = static_cast(this->dim_size()); i < n; i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, this->dim(static_cast(i)), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TensorShapeProto) +} + +::google::protobuf::uint8* TensorShapeProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TensorShapeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1; + for (unsigned int i = 0, + n = static_cast(this->dim_size()); i < n; i++) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, this->dim(static_cast(i)), deterministic, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TensorShapeProto) + return target; +} + +size_t TensorShapeProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TensorShapeProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // repeated .opencv_onnx.TensorShapeProto.Dimension dim = 1; + { + unsigned int count = static_cast(this->dim_size()); + total_size += 1UL * count; + for (unsigned int i = 0; i < count; i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSize( + this->dim(static_cast(i))); + } + } + + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TensorShapeProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TensorShapeProto) + GOOGLE_DCHECK_NE(&from, this); + const TensorShapeProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TensorShapeProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TensorShapeProto) + MergeFrom(*source); + } +} + +void TensorShapeProto::MergeFrom(const TensorShapeProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TensorShapeProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + dim_.MergeFrom(from.dim_); +} + +void TensorShapeProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TensorShapeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TensorShapeProto::CopyFrom(const TensorShapeProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TensorShapeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TensorShapeProto::IsInitialized() const { + return true; +} + +void TensorShapeProto::Swap(TensorShapeProto* other) { + if (other == this) return; + InternalSwap(other); +} +void TensorShapeProto::InternalSwap(TensorShapeProto* other) { + using std::swap; + dim_.InternalSwap(&other->dim_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TensorShapeProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TypeProto_Tensor::InitAsDefaultInstance() { + ::opencv_onnx::_TypeProto_Tensor_default_instance_._instance.get_mutable()->shape_ = const_cast< ::opencv_onnx::TensorShapeProto*>( + ::opencv_onnx::TensorShapeProto::internal_default_instance()); +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TypeProto_Tensor::kElemTypeFieldNumber; +const int TypeProto_Tensor::kShapeFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TypeProto_Tensor::TypeProto_Tensor() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto_Tensor(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TypeProto.Tensor) +} +TypeProto_Tensor::TypeProto_Tensor(const TypeProto_Tensor& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from.has_shape()) { + shape_ = new ::opencv_onnx::TensorShapeProto(*from.shape_); + } else { + shape_ = NULL; + } + elem_type_ = from.elem_type_; + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TypeProto.Tensor) +} + +void TypeProto_Tensor::SharedCtor() { + _cached_size_ = 0; + ::memset(&shape_, 0, static_cast( + reinterpret_cast(&elem_type_) - + reinterpret_cast(&shape_)) + sizeof(elem_type_)); +} + +TypeProto_Tensor::~TypeProto_Tensor() { + // @@protoc_insertion_point(destructor:opencv_onnx.TypeProto.Tensor) + SharedDtor(); +} + +void TypeProto_Tensor::SharedDtor() { + if (this != internal_default_instance()) delete shape_; +} + +void TypeProto_Tensor::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TypeProto_Tensor::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TypeProto_Tensor& TypeProto_Tensor::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto_Tensor(); + return *internal_default_instance(); +} + +TypeProto_Tensor* TypeProto_Tensor::New(::google::protobuf::Arena* arena) const { + TypeProto_Tensor* n = new TypeProto_Tensor; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TypeProto_Tensor::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TypeProto.Tensor) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(shape_ != NULL); + shape_->Clear(); + } + elem_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TypeProto_Tensor::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TypeProto.Tensor) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .opencv_onnx.TensorProto.DataType elem_type = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (::opencv_onnx::TensorProto_DataType_IsValid(value)) { + set_elem_type(static_cast< ::opencv_onnx::TensorProto_DataType >(value)); + } else { + mutable_unknown_fields()->AddVarint( + 1, static_cast< ::google::protobuf::uint64>(value)); + } + } else { + goto handle_unusual; + } + break; + } + + // optional .opencv_onnx.TensorShapeProto shape = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_shape())); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TypeProto.Tensor) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TypeProto.Tensor) + return false; +#undef DO_ +} + +void TypeProto_Tensor::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TypeProto.Tensor) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_onnx.TensorProto.DataType elem_type = 1; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 1, this->elem_type(), output); + } + + // optional .opencv_onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 2, *this->shape_, output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TypeProto.Tensor) +} + +::google::protobuf::uint8* TypeProto_Tensor::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TypeProto.Tensor) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .opencv_onnx.TensorProto.DataType elem_type = 1; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 1, this->elem_type(), target); + } + + // optional .opencv_onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 2, *this->shape_, deterministic, target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TypeProto.Tensor) + return target; +} + +size_t TypeProto_Tensor::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TypeProto.Tensor) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + if (_has_bits_[0 / 32] & 3u) { + // optional .opencv_onnx.TensorShapeProto shape = 2; + if (has_shape()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *this->shape_); + } + + // optional .opencv_onnx.TensorProto.DataType elem_type = 1; + if (has_elem_type()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->elem_type()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TypeProto_Tensor::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TypeProto.Tensor) + GOOGLE_DCHECK_NE(&from, this); + const TypeProto_Tensor* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TypeProto.Tensor) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TypeProto.Tensor) + MergeFrom(*source); + } +} + +void TypeProto_Tensor::MergeFrom(const TypeProto_Tensor& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TypeProto.Tensor) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + mutable_shape()->::opencv_onnx::TensorShapeProto::MergeFrom(from.shape()); + } + if (cached_has_bits & 0x00000002u) { + elem_type_ = from.elem_type_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void TypeProto_Tensor::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TypeProto.Tensor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TypeProto_Tensor::CopyFrom(const TypeProto_Tensor& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TypeProto.Tensor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_Tensor::IsInitialized() const { + return true; +} + +void TypeProto_Tensor::Swap(TypeProto_Tensor* other) { + if (other == this) return; + InternalSwap(other); +} +void TypeProto_Tensor::InternalSwap(TypeProto_Tensor* other) { + using std::swap; + swap(shape_, other->shape_); + swap(elem_type_, other->elem_type_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TypeProto_Tensor::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void TypeProto::InitAsDefaultInstance() { + ::opencv_onnx::_TypeProto_default_instance_.tensor_type_ = const_cast< ::opencv_onnx::TypeProto_Tensor*>( + ::opencv_onnx::TypeProto_Tensor::internal_default_instance()); +} +void TypeProto::set_allocated_tensor_type(::opencv_onnx::TypeProto_Tensor* tensor_type) { + ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); + clear_value(); + if (tensor_type) { + ::google::protobuf::Arena* submessage_arena = NULL; + if (message_arena != submessage_arena) { + tensor_type = ::google::protobuf::internal::GetOwnedMessage( + message_arena, tensor_type, submessage_arena); + } + set_has_tensor_type(); + value_.tensor_type_ = tensor_type; + } + // @@protoc_insertion_point(field_set_allocated:opencv_onnx.TypeProto.tensor_type) +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int TypeProto::kTensorTypeFieldNumber; +const int TypeProto::kDenotationFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +TypeProto::TypeProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.TypeProto) +} +TypeProto::TypeProto(const TypeProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + denotation_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_denotation()) { + denotation_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.denotation_); + } + clear_has_value(); + switch (from.value_case()) { + case kTensorType: { + mutable_tensor_type()->::opencv_onnx::TypeProto_Tensor::MergeFrom(from.tensor_type()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:opencv_onnx.TypeProto) +} + +void TypeProto::SharedCtor() { + _cached_size_ = 0; + denotation_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + clear_has_value(); +} + +TypeProto::~TypeProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.TypeProto) + SharedDtor(); +} + +void TypeProto::SharedDtor() { + denotation_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (has_value()) { + clear_value(); + } +} + +void TypeProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* TypeProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const TypeProto& TypeProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsTypeProto(); + return *internal_default_instance(); +} + +TypeProto* TypeProto::New(::google::protobuf::Arena* arena) const { + TypeProto* n = new TypeProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void TypeProto::clear_value() { +// @@protoc_insertion_point(one_of_clear_start:opencv_onnx.TypeProto) + switch (value_case()) { + case kTensorType: { + delete value_.tensor_type_; + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + + +void TypeProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.TypeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!denotation_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*denotation_.UnsafeRawStringPointer())->clear(); + } + clear_value(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool TypeProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.TypeProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( + input, mutable_tensor_type())); + } else { + goto handle_unusual; + } + break; + } + + // optional string denotation = 6; + case 6: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_denotation())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.TypeProto.denotation"); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.TypeProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.TypeProto) + return false; +#undef DO_ +} + +void TypeProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.TypeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1; + if (has_tensor_type()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 1, *value_.tensor_type_, output); + } + + cached_has_bits = _has_bits_[0]; + // optional string denotation = 6; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TypeProto.denotation"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 6, this->denotation(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.TypeProto) +} + +::google::protobuf::uint8* TypeProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.TypeProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1; + if (has_tensor_type()) { + target = ::google::protobuf::internal::WireFormatLite:: + InternalWriteMessageToArray( + 1, *value_.tensor_type_, deterministic, target); + } + + cached_has_bits = _has_bits_[0]; + // optional string denotation = 6; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->denotation().data(), static_cast(this->denotation().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.TypeProto.denotation"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 6, this->denotation(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.TypeProto) + return target; +} + +size_t TypeProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.TypeProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + // optional string denotation = 6; + if (has_denotation()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->denotation()); + } + + switch (value_case()) { + // optional .opencv_onnx.TypeProto.Tensor tensor_type = 1; + case kTensorType: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize( + *value_.tensor_type_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void TypeProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.TypeProto) + GOOGLE_DCHECK_NE(&from, this); + const TypeProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.TypeProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.TypeProto) + MergeFrom(*source); + } +} + +void TypeProto::MergeFrom(const TypeProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.TypeProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_denotation()) { + set_has_denotation(); + denotation_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.denotation_); + } + switch (from.value_case()) { + case kTensorType: { + mutable_tensor_type()->::opencv_onnx::TypeProto_Tensor::MergeFrom(from.tensor_type()); + break; + } + case VALUE_NOT_SET: { + break; + } + } +} + +void TypeProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.TypeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void TypeProto::CopyFrom(const TypeProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.TypeProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool TypeProto::IsInitialized() const { + return true; +} + +void TypeProto::Swap(TypeProto* other) { + if (other == this) return; + InternalSwap(other); +} +void TypeProto::InternalSwap(TypeProto* other) { + using std::swap; + denotation_.Swap(&other->denotation_); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata TypeProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// =================================================================== + +void OperatorSetIdProto::InitAsDefaultInstance() { +} +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +const int OperatorSetIdProto::kDomainFieldNumber; +const int OperatorSetIdProto::kVersionFieldNumber; +#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 + +OperatorSetIdProto::OperatorSetIdProto() + : ::google::protobuf::Message(), _internal_metadata_(NULL) { + if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsOperatorSetIdProto(); + } + SharedCtor(); + // @@protoc_insertion_point(constructor:opencv_onnx.OperatorSetIdProto) +} +OperatorSetIdProto::OperatorSetIdProto(const OperatorSetIdProto& from) + : ::google::protobuf::Message(), + _internal_metadata_(NULL), + _has_bits_(from._has_bits_), + _cached_size_(0) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + if (from.has_domain()) { + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + version_ = from.version_; + // @@protoc_insertion_point(copy_constructor:opencv_onnx.OperatorSetIdProto) +} + +void OperatorSetIdProto::SharedCtor() { + _cached_size_ = 0; + domain_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); + version_ = GOOGLE_LONGLONG(0); +} + +OperatorSetIdProto::~OperatorSetIdProto() { + // @@protoc_insertion_point(destructor:opencv_onnx.OperatorSetIdProto) + SharedDtor(); +} + +void OperatorSetIdProto::SharedDtor() { + domain_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); +} + +void OperatorSetIdProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* OperatorSetIdProto::descriptor() { + ::protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; +} + +const OperatorSetIdProto& OperatorSetIdProto::default_instance() { + ::protobuf_opencv_2donnx_2eproto::InitDefaultsOperatorSetIdProto(); + return *internal_default_instance(); +} + +OperatorSetIdProto* OperatorSetIdProto::New(::google::protobuf::Arena* arena) const { + OperatorSetIdProto* n = new OperatorSetIdProto; + if (arena != NULL) { + arena->Own(n); + } + return n; +} + +void OperatorSetIdProto::Clear() { +// @@protoc_insertion_point(message_clear_start:opencv_onnx.OperatorSetIdProto) + ::google::protobuf::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(!domain_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited())); + (*domain_.UnsafeRawStringPointer())->clear(); + } + version_ = GOOGLE_LONGLONG(0); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +bool OperatorSetIdProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure + ::google::protobuf::uint32 tag; + // @@protoc_insertion_point(parse_start:opencv_onnx.OperatorSetIdProto) + for (;;) { + ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); + tag = p.first; + if (!p.second) goto handle_unusual; + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // optional string domain = 1; + case 1: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_domain())); + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::PARSE, + "opencv_onnx.OperatorSetIdProto.domain"); + } else { + goto handle_unusual; + } + break; + } + + // optional int64 version = 2; + case 2: { + if (static_cast< ::google::protobuf::uint8>(tag) == + static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { + set_has_version(); + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>( + input, &version_))); + } else { + goto handle_unusual; + } + break; + } + + default: { + handle_unusual: + if (tag == 0) { + goto success; + } + DO_(::google::protobuf::internal::WireFormat::SkipField( + input, tag, _internal_metadata_.mutable_unknown_fields())); + break; + } + } + } +success: + // @@protoc_insertion_point(parse_success:opencv_onnx.OperatorSetIdProto) + return true; +failure: + // @@protoc_insertion_point(parse_failure:opencv_onnx.OperatorSetIdProto) + return false; +#undef DO_ +} + +void OperatorSetIdProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // @@protoc_insertion_point(serialize_start:opencv_onnx.OperatorSetIdProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string domain = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.OperatorSetIdProto.domain"); + ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( + 1, this->domain(), output); + } + + // optional int64 version = 2; + if (cached_has_bits & 0x00000002u) { + ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->version(), output); + } + + if (_internal_metadata_.have_unknown_fields()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + _internal_metadata_.unknown_fields(), output); + } + // @@protoc_insertion_point(serialize_end:opencv_onnx.OperatorSetIdProto) +} + +::google::protobuf::uint8* OperatorSetIdProto::InternalSerializeWithCachedSizesToArray( + bool deterministic, ::google::protobuf::uint8* target) const { + (void)deterministic; // Unused + // @@protoc_insertion_point(serialize_to_array_start:opencv_onnx.OperatorSetIdProto) + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string domain = 1; + if (cached_has_bits & 0x00000001u) { + ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( + this->domain().data(), static_cast(this->domain().length()), + ::google::protobuf::internal::WireFormat::SERIALIZE, + "opencv_onnx.OperatorSetIdProto.domain"); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->domain(), target); + } + + // optional int64 version = 2; + if (cached_has_bits & 0x00000002u) { + target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->version(), target); + } + + if (_internal_metadata_.have_unknown_fields()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields(), target); + } + // @@protoc_insertion_point(serialize_to_array_end:opencv_onnx.OperatorSetIdProto) + return target; +} + +size_t OperatorSetIdProto::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:opencv_onnx.OperatorSetIdProto) + size_t total_size = 0; + + if (_internal_metadata_.have_unknown_fields()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + _internal_metadata_.unknown_fields()); + } + if (_has_bits_[0 / 32] & 3u) { + // optional string domain = 1; + if (has_domain()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->domain()); + } + + // optional int64 version = 2; + if (has_version()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int64Size( + this->version()); + } + + } + int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = cached_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void OperatorSetIdProto::MergeFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:opencv_onnx.OperatorSetIdProto) + GOOGLE_DCHECK_NE(&from, this); + const OperatorSetIdProto* source = + ::google::protobuf::internal::DynamicCastToGenerated( + &from); + if (source == NULL) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_onnx.OperatorSetIdProto) + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_onnx.OperatorSetIdProto) + MergeFrom(*source); + } +} + +void OperatorSetIdProto::MergeFrom(const OperatorSetIdProto& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:opencv_onnx.OperatorSetIdProto) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom(from._internal_metadata_); + ::google::protobuf::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 3u) { + if (cached_has_bits & 0x00000001u) { + set_has_domain(); + domain_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.domain_); + } + if (cached_has_bits & 0x00000002u) { + version_ = from.version_; + } + _has_bits_[0] |= cached_has_bits; + } +} + +void OperatorSetIdProto::CopyFrom(const ::google::protobuf::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:opencv_onnx.OperatorSetIdProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void OperatorSetIdProto::CopyFrom(const OperatorSetIdProto& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:opencv_onnx.OperatorSetIdProto) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool OperatorSetIdProto::IsInitialized() const { + return true; +} + +void OperatorSetIdProto::Swap(OperatorSetIdProto* other) { + if (other == this) return; + InternalSwap(other); +} +void OperatorSetIdProto::InternalSwap(OperatorSetIdProto* other) { + using std::swap; + domain_.Swap(&other->domain_); + swap(version_, other->version_); + swap(_has_bits_[0], other->_has_bits_[0]); + _internal_metadata_.Swap(&other->_internal_metadata_); + swap(_cached_size_, other->_cached_size_); +} + +::google::protobuf::Metadata OperatorSetIdProto::GetMetadata() const { + protobuf_opencv_2donnx_2eproto::protobuf_AssignDescriptorsOnce(); + return ::protobuf_opencv_2donnx_2eproto::file_level_metadata[kIndexInFileMessages]; +} + + +// @@protoc_insertion_point(namespace_scope) +} // namespace opencv_onnx + +// @@protoc_insertion_point(global_scope) diff --git a/modules/dnn/misc/onnx/opencv-onnx.pb.h b/modules/dnn/misc/onnx/opencv-onnx.pb.h new file mode 100644 index 0000000000..9959d493e2 --- /dev/null +++ b/modules/dnn/misc/onnx/opencv-onnx.pb.h @@ -0,0 +1,5849 @@ +// 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 + +#include + +#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 +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@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_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_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_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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( + &_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(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(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(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(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( + &::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( + &::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(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(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(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( + &::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(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(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(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(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(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(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(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(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(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(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(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(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(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( + &::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(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(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(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(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( + &::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(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(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(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(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(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(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(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( + &::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(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(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 diff --git a/modules/dnn/src/dnn.cpp b/modules/dnn/src/dnn.cpp index 46e4017912..e48659e31c 100644 --- a/modules/dnn/src/dnn.cpp +++ b/modules/dnn/src/dnn.cpp @@ -3462,6 +3462,10 @@ Net readNet(const String& _model, const String& _config, const String& _framewor std::swap(model, config); return readNetFromModelOptimizer(config, model); } + if (framework == "onnx" || modelExt == "onnx") + { + return readNetFromONNX(model); + } CV_Error(Error::StsError, "Cannot determine an origin framework of files: " + model + (config.empty() ? "" : ", " + config)); } diff --git a/modules/dnn/src/onnx/onnx_importer.cpp b/modules/dnn/src/onnx/onnx_importer.cpp new file mode 100644 index 0000000000..bd10e1dedf --- /dev/null +++ b/modules/dnn/src/onnx/onnx_importer.cpp @@ -0,0 +1,585 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "../precomp.hpp" + +#ifdef HAVE_PROTOBUF + +#include +#include +#include +#include +#include + + +#if defined(__GNUC__) && __GNUC__ >= 5 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wsuggest-override" +#endif +#include "opencv-onnx.pb.h" +#if defined(__GNUC__) && __GNUC__ >= 5 +#pragma GCC diagnostic pop +#endif + +namespace cv { +namespace dnn { +CV__DNN_EXPERIMENTAL_NS_BEGIN + + +class ONNXImporter +{ + opencv_onnx::ModelProto model_proto; + struct LayerInfo { + int layerId; + int outputId; + LayerInfo(int _layerId, int _outputId) : layerId(_layerId), outputId(_outputId) {} + }; + + std::map getGraphTensors( + const opencv_onnx::GraphProto& graph_proto); + Mat getBlob(const opencv_onnx::NodeProto& node_proto, const std::map& constBlobs, int index); + + LayerParams getLayerParams(const opencv_onnx::NodeProto& node_proto); + bool isCeilMode(const LayerParams& layerParams); + +public: + + ONNXImporter(const char *onnxFile) + { + std::fstream input(onnxFile, std::ios::in | std::ios::binary); + + if (!model_proto.ParseFromIstream(&input)) + CV_Error(Error::StsUnsupportedFormat, "Failed to parse onnx model"); + } + + void populateNet(Net dstNet); +}; + +inline void replaceLayerParam(LayerParams& layerParams, const String& oldKey, const String& newKey) +{ + if (layerParams.has(oldKey)) { + layerParams.set(newKey, layerParams.get(oldKey)); + layerParams.erase(oldKey); + } +} + +void releaseONNXTensor(opencv_onnx::TensorProto& tensor_proto) +{ + if (!tensor_proto.raw_data().empty()) { + delete tensor_proto.release_raw_data(); + } +} + +template +void convertInt64ToInt32(const T1& src, T2& dst, int size) +{ + for (int i = 0; i < size; i++) { + if (src[i] < std::numeric_limits::min() || src[i] > std::numeric_limits::max()) { + CV_Error(Error::StsOutOfRange, "Input is out of OpenCV 32S range"); + } + dst[i] = saturate_cast(src[i]); + } +} + +Mat getMatFromTensor(opencv_onnx::TensorProto& tensor_proto) +{ + CV_Assert(!tensor_proto.raw_data().empty() || !tensor_proto.float_data().empty() + || !tensor_proto.double_data().empty() || !tensor_proto.int64_data().empty()); + + opencv_onnx::TensorProto_DataType datatype = tensor_proto.data_type(); + Mat blob; + std::vector sizes; + for (int i = 0; i < tensor_proto.dims_size(); i++) { + sizes.push_back(tensor_proto.dims(i)); + } + if (datatype == opencv_onnx::TensorProto_DataType_FLOAT) { + + if (!tensor_proto.float_data().empty()) { + const ::google::protobuf::RepeatedField field = tensor_proto.float_data(); + Mat(sizes, CV_32FC1, (void*)field.data()).copyTo(blob); + } + else { + char* val = const_cast(tensor_proto.raw_data().c_str()); + Mat(sizes, CV_32FC1, val).copyTo(blob); + } + } + else if (datatype == opencv_onnx::TensorProto_DataType_DOUBLE) + { + const ::google::protobuf::RepeatedField field = tensor_proto.double_data(); + CV_Assert(!field.empty()); + Mat(sizes, CV_64FC1, (void*)field.data()).convertTo(blob, CV_32FC1); + } + else if (datatype == opencv_onnx::TensorProto_DataType_INT64) + { + blob.create(sizes, CV_32SC1); + int32_t* dst = reinterpret_cast(blob.data); + + if (!tensor_proto.int64_data().empty()) { + ::google::protobuf::RepeatedField< ::google::protobuf::int64> src = tensor_proto.int64_data(); + convertInt64ToInt32(src, dst, blob.total()); + } + else + { + char* val = const_cast(tensor_proto.raw_data().c_str()); + int64_t* src = reinterpret_cast(val); + convertInt64ToInt32(src, dst, blob.total()); + } + } + else + CV_Error(Error::StsUnsupportedFormat, "Unsupported data type: " + + opencv_onnx::TensorProto_DataType_Name(datatype)); + return blob; +} + +std::map ONNXImporter::getGraphTensors( + const opencv_onnx::GraphProto& graph_proto) +{ + opencv_onnx::TensorProto tensor_proto; + std::map layers_weights; + + for (int i = 0; i < graph_proto.initializer_size(); i++) + { + tensor_proto = graph_proto.initializer(i); + Mat mat = getMatFromTensor(tensor_proto); + releaseONNXTensor(tensor_proto); + layers_weights.insert(std::make_pair(tensor_proto.name(), mat)); + } + return layers_weights; +} + +LayerParams ONNXImporter::getLayerParams(const opencv_onnx::NodeProto& node_proto) +{ + LayerParams lp; + for(int i = 0; i < node_proto.attribute_size(); i++) + { + opencv_onnx::AttributeProto attribute_proto = node_proto.attribute(i); + std::string attribute_name = attribute_proto.name(); + + if(attribute_name == "kernel_shape") + { + CV_Assert(attribute_proto.ints_size() == 2); + lp.set("kernel_h", saturate_cast(attribute_proto.ints(0))); + lp.set("kernel_w", saturate_cast(attribute_proto.ints(1))); + } + else if(attribute_name == "strides") + { + CV_Assert(attribute_proto.ints_size() == 2); + lp.set("stride_h", saturate_cast(attribute_proto.ints(0))); + lp.set("stride_w", saturate_cast(attribute_proto.ints(1))); + } + else if(attribute_name == "pads") + { + CV_Assert(attribute_proto.ints_size() == 4); + lp.set("pad_h", saturate_cast(attribute_proto.ints(0))); + lp.set("pad_w", saturate_cast(attribute_proto.ints(1))); + // push pad_b and pad_r for compute ceil_mode + lp.set("pad_b", saturate_cast(attribute_proto.ints(2))); + lp.set("pad_r", saturate_cast(attribute_proto.ints(3))); + } + else if(attribute_name == "auto_pad") + { + if (attribute_proto.s() == "SAME_UPPER" || attribute_proto.s() == "SAME_LOWER") { + lp.set("pad_mode", "SAME"); + } + else if (attribute_proto.s() == "VALID") { + lp.set("pad_mode", "VALID"); + } + } + else if(attribute_name == "dilations") + { + CV_Assert(attribute_proto.ints_size() == 2); + lp.set("dilation_h", saturate_cast(attribute_proto.ints(0))); + lp.set("dilation_w", saturate_cast(attribute_proto.ints(1))); + } + else if (attribute_proto.has_i()) + { + ::google::protobuf::int64 src = attribute_proto.i(); + if (src < std::numeric_limits::min() || src > std::numeric_limits::max()) + CV_Error(Error::StsOutOfRange, "Input is out of OpenCV 32S range"); + else + lp.set(attribute_name, saturate_cast(src)); + } + else if (attribute_proto.has_f()) + { + lp.set(attribute_name, attribute_proto.f()); + } + else if (attribute_proto.has_s()) + { + lp.set(attribute_name, attribute_proto.s()); + } + else if (attribute_proto.floats_size() > 0) + { + lp.set(attribute_name, DictValue::arrayReal( + (float*)attribute_proto.mutable_floats(), attribute_proto.floats_size())); + } + else if (attribute_proto.ints_size() > 0) + { + const ::google::protobuf::RepeatedField< ::google::protobuf::int64> src = attribute_proto.ints(); + std::vector dst(attribute_proto.ints_size()); + convertInt64ToInt32(src, dst, attribute_proto.ints_size()); + lp.set(attribute_proto.name(), DictValue::arrayInt(&dst[0], attribute_proto.ints_size())); + } + else if (attribute_proto.has_t()) + { + opencv_onnx::TensorProto tensor = attribute_proto.t(); + Mat blob = getMatFromTensor(tensor); + lp.blobs.push_back(blob); + } + else if (attribute_proto.has_g() || attribute_proto.strings_size() > 0 || + attribute_proto.tensors_size() > 0 || attribute_proto.graphs_size() > 0) + { + CV_Error(Error::StsNotImplemented, "Unexpected attribute type"); + } + else + CV_Error(Error::StsNotImplemented, "Unsupported attribute type"); + } + return lp; +} + +Mat ONNXImporter::getBlob(const opencv_onnx::NodeProto& node_proto, + const std::map& constBlobs, int index) +{ + CV_Assert(index < node_proto.input_size()); + std::map::const_iterator constBlob; + constBlob = constBlobs.find(node_proto.input(index)); + if (constBlob == constBlobs.end()) { + CV_Error(Error::StsObjectNotFound, + "Blob " + node_proto.input(index) + " not found in const blobs"); + } + return constBlob->second; +} + + +bool ONNXImporter::isCeilMode(const LayerParams& layerParams) { + if (!layerParams.has("pad_mode")) { + if (layerParams.has("pad_h")) { + return layerParams.get("pad_h") != layerParams.get("pad_b") || + layerParams.get("pad_w") != layerParams.get("pad_r"); + } + else + return false; // all pads == 0 + } + return true; +} + +void ONNXImporter::populateNet(Net dstNet) +{ + CV_Assert(model_proto.has_graph()); + opencv_onnx::GraphProto graph_proto = model_proto.graph(); + std::map constBlobs = getGraphTensors(graph_proto); + + std::string framework_name; + if (model_proto.has_producer_name()) { + framework_name = model_proto.producer_name(); + } + + // create map with network inputs (without const blobs) + std::map layer_id; + std::map::iterator layerId; + // fill map: push layer name, layer id and output id + std::vector netInputs; + for (int j = 0; j < graph_proto.input_size(); j++) + { + const std::string& name = graph_proto.input(j).name(); + if (constBlobs.find(name) == constBlobs.end()) { + netInputs.push_back(name); + layer_id.insert(std::make_pair(name, LayerInfo(0, netInputs.size() - 1))); + } + } + dstNet.setInputsNames(netInputs); + + int layersSize = graph_proto.node_size(); + LayerParams layerParams; + opencv_onnx::NodeProto node_proto; + + for(int i = 0; i < layersSize; i++) + { + node_proto = graph_proto.node(i); + layerParams = getLayerParams(node_proto); + CV_Assert(node_proto.output_size() >= 1); + layerParams.name = node_proto.output(0); + + std::string layer_type = node_proto.op_type(); + layerParams.type = layer_type; + + if (layer_type == "MaxPool") + { + layerParams.type = "Pooling"; + layerParams.set("pool", "MAX"); + layerParams.set("ceil_mode", isCeilMode(layerParams)); + } + else if (layer_type == "AveragePool") + { + layerParams.type = "Pooling"; + layerParams.set("pool", "AVE"); + layerParams.set("ceil_mode", isCeilMode(layerParams)); + layerParams.set("ave_pool_padded_area", framework_name == "pytorch"); + } + else if (layer_type == "GlobalAveragePool") + { + layerParams.type = "Pooling"; + layerParams.set("pool", "AVE"); + layerParams.set("global_pooling", true); + } + else if (layer_type == "Add" || layer_type == "Sum") + { + if (layer_id.find(node_proto.input(1)) == layer_id.end()) + { + Mat blob = getBlob(node_proto, constBlobs, 1); + blob = blob.reshape(1, 1); + if (blob.total() == 1) { + layerParams.type = "Power"; + layerParams.set("shift", blob.at(0)); + } + else { + layerParams.type = "Shift"; + layerParams.blobs.push_back(blob); + } + } + else { + layerParams.type = "Eltwise"; + } + } + else if (layer_type == "Sub") + { + Mat blob = (-1.0f) * getBlob(node_proto, constBlobs, 1); + blob = blob.reshape(1, 1); + if (blob.total() == 1) { + layerParams.type = "Power"; + layerParams.set("shift", blob.at(0)); + } + else { + layerParams.type = "Shift"; + layerParams.blobs.push_back(blob); + } + } + else if (layer_type == "Constant") + { + CV_Assert(node_proto.input_size() == 0); + CV_Assert(layerParams.blobs.size() == 1); + constBlobs.insert(std::make_pair(layerParams.name, layerParams.blobs[0])); + continue; + } + else if (layer_type == "ImageScaler") + { + const float scale = layerParams.has("scale") ? layerParams.get("scale") : 1.0f; + layerParams.erase("scale"); + + if (layerParams.has("bias")) + { + layerParams.type = "Scale"; + layerParams.blobs.push_back( + Mat(Size(1, layerParams.get("bias").size()), CV_32FC1, scale)); + + layerParams.set("bias_term", true); + Mat bias(1, layerParams.get("bias").size(), CV_32FC1); + for (int j = 0; j < bias.total(); j++) { + bias.at(0, j) = layerParams.get("bias").getRealValue(j); + } + layerParams.blobs.push_back(bias); + layerParams.erase("bias"); + } + else { + layerParams.set("scale", scale); + layerParams.type = "Power"; + } + } + else if (layer_type == "LeakyRelu") + { + layerParams.type = "ReLU"; + replaceLayerParam(layerParams, "alpha", "negative_slope"); + } + else if (layer_type == "LRN") + { + replaceLayerParam(layerParams, "size", "local_size"); + } + else if (layer_type == "BatchNormalization") + { + if (node_proto.input_size() != 5) + CV_Error(Error::StsNotImplemented, + "Expected input, scale, bias, mean and var"); + + layerParams.type = "BatchNorm"; + replaceLayerParam(layerParams, "epsilon", "eps"); + replaceLayerParam(layerParams, "spatial", "use_global_stats"); + + Mat meanData = getBlob(node_proto, constBlobs, 3); + Mat stdData = getBlob(node_proto, constBlobs, 4); + + layerParams.blobs.push_back(meanData); + layerParams.blobs.push_back(stdData); + + if (!node_proto.input(1).empty()) { + layerParams.set("has_weight", true); + layerParams.blobs.push_back(getBlob(node_proto, constBlobs, 1)); // weightData + } else { + layerParams.set("has_weight", false); + } + + if (!node_proto.input(2).empty()) { + layerParams.set("has_bias", true); + layerParams.blobs.push_back(getBlob(node_proto, constBlobs, 2)); // biasData + } else { + layerParams.set("has_bias", false); + } + } + else if (layer_type == "Gemm") + { + CV_Assert(node_proto.input_size() >= 2); + layerParams.type = "InnerProduct"; + Mat weights = getBlob(node_proto, constBlobs, 1); + int ind_num_out = 0; + if (layerParams.has("transB") && !layerParams.get("transB")) { + transpose(weights, weights); + ind_num_out = 1; + } + layerParams.blobs.push_back(weights); + + if (node_proto.input_size() == 3) { + Mat bias = getBlob(node_proto, constBlobs, 2); + layerParams.blobs.push_back(bias); + } + + layerParams.set("num_output", layerParams.blobs[0].size[ind_num_out]); + layerParams.set("bias_term", node_proto.input_size() == 3); + } + else if (layer_type == "MatMul") + { + CV_Assert(node_proto.input_size() == 2); + layerParams.type = "InnerProduct"; + Mat blob = getBlob(node_proto, constBlobs, 1); + layerParams.blobs.push_back(blob.t()); + layerParams.set("bias_term", false); + layerParams.set("num_output", layerParams.blobs[0].size[0]); + } + else if (layer_type == "Mul") + { + CV_Assert(node_proto.input_size() == 2); + if (layer_id.find(node_proto.input(1)) == layer_id.end()) { + Mat blob = getBlob(node_proto, constBlobs, 1); + blob = blob.reshape(1, 1); + if (blob.total() == 1) { + layerParams.set("scale", blob.at(0)); + layerParams.type = "Power"; + } + else { + layerParams.blobs.push_back(blob); + layerParams.type = "Scale"; + } + } + else { + layerParams.type = "Eltwise"; + layerParams.set("operation", "prod"); + } + } + else if (layer_type == "Conv") + { + CV_Assert(node_proto.input_size() >= 2); + layerParams.type = "Convolution"; + for (int j = 1; j < node_proto.input_size(); j++) { + layerParams.blobs.push_back(getBlob(node_proto, constBlobs, j)); + } + layerParams.set("num_output", layerParams.blobs[0].size[0]); + layerParams.set("bias_term", node_proto.input_size() == 3); + } + else if (layer_type == "Unsqueeze") + { + CV_Assert(node_proto.input_size() == 1); + Mat input = getBlob(node_proto, constBlobs, 0); + + DictValue axes = layerParams.get("axes"); + std::vector dims; + for (int j = 0; j < input.dims; j++) { + dims.push_back(input.size[j]); + } + CV_Assert(axes.getIntValue(axes.size()-1) <= dims.size()); + for (int j = 0; j < axes.size(); j++) { + dims.insert(dims.begin() + axes.getIntValue(j), 1); + } + + Mat out = input.reshape(0, dims); + constBlobs.insert(std::make_pair(layerParams.name, out)); + continue; + } + else if (layer_type == "Reshape") + { + CV_Assert(node_proto.input_size() == 2 || layerParams.has("shape")); + + if (node_proto.input_size() == 2) { + Mat blob = getBlob(node_proto, constBlobs, 1); + CV_Assert(blob.type() == CV_32SC1); + + if (layer_id.find(node_proto.input(0)) == layer_id.end()) { + Mat input = getBlob(node_proto, constBlobs, 0); + Mat out = input.reshape(0, static_cast >(blob)); + constBlobs.insert(std::make_pair(layerParams.name, out)); + continue; + } + layerParams.set("dim", DictValue::arrayInt( + blob.ptr(), blob.total() )); + } + else { + DictValue shape = layerParams.get("shape"); + std::vector dim; + for (int j = 0; j < shape.size(); j++) { + dim.push_back(shape.getIntValue(j)); + } + + if (layer_id.find(node_proto.input(0)) == layer_id.end()) { + Mat input = getBlob(node_proto, constBlobs, 0); + Mat out = input.reshape(0, dim); + constBlobs.insert(std::make_pair(layerParams.name, out)); + continue; + } + replaceLayerParam(layerParams, "shape", "dim"); + } + } + else + { + for (int j = 0; j < node_proto.input_size(); j++) { + if (layer_id.find(node_proto.input(j)) == layer_id.end()) + layerParams.blobs.push_back(getBlob(node_proto, constBlobs, j)); + } + } + + int id = dstNet.addLayer(layerParams.name, layerParams.type, layerParams); + layer_id.insert(std::make_pair(layerParams.name, LayerInfo(id, 0))); + + for (int j = 0; j < node_proto.input_size(); j++) { + layerId = layer_id.find(node_proto.input(j)); + + if (layerId != layer_id.end()) { + dstNet.connect(layerId->second.layerId, layerId->second.outputId, id, j); + } + } + } + } + +Net readNetFromONNX(const String& onnxFile) +{ + ONNXImporter onnxImporter(onnxFile.c_str()); + Net net; + onnxImporter.populateNet(net); + return net; +} + +Mat readTensorFromONNX(const String& path) +{ + opencv_onnx::TensorProto tensor_proto = opencv_onnx::TensorProto(); + std::fstream input(path.c_str(), std::ios::in | std::ios::binary); + if (!tensor_proto.ParseFromIstream(&input)) { + CV_Error(Error::StsUnsupportedFormat, "Failed to parse data"); + } + Mat mat = getMatFromTensor(tensor_proto); + releaseONNXTensor(tensor_proto); + return mat; +} + +CV__DNN_EXPERIMENTAL_NS_END +}} // namespace + +#endif diff --git a/modules/dnn/src/onnx/opencv-onnx.proto b/modules/dnn/src/onnx/opencv-onnx.proto new file mode 100644 index 0000000000..6433d5d6cb --- /dev/null +++ b/modules/dnn/src/onnx/opencv-onnx.proto @@ -0,0 +1,446 @@ +// +// WARNING: This file is automatically generated! Please edit onnx.in.proto. +// + + +// Copyright (c) Facebook Inc. and Microsoft Corporation. +// Licensed under the MIT license. + +syntax = "proto2"; + +package opencv_onnx; + +// Overview +// +// ONNX is an open specification that is comprised of the following components: +// +// 1) A definition of an extensible computation graph model. +// 2) Definitions of standard data types. +// 3) Definitions of built-in operators. +// +// This document describes the syntax of models and their computation graphs, +// as well as the standard data types. Together, they are referred to as the ONNX +// Intermediate Representation, or 'IR' for short. +// +// The normative semantic specification of the ONNX IR is found in docs/IR.md. +// Definitions of the built-in neural network operators may be found in docs/Operators.md. + +// Notes +// +// Release +// +// We are still in the very early stage of defining ONNX. The current +// version of ONNX is a starting point. While we are actively working +// towards a complete spec, we would like to get the community involved +// by sharing our working version of ONNX. +// +// Protobuf compatibility +// +// To simplify framework compatibility, ONNX is defined using the subset of protobuf +// that is compatible with both protobuf v2 and v3. This means that we do not use any +// protobuf features that are only available in one of the two versions. +// +// Here are the most notable contortions we have to carry out to work around +// these limitations: +// +// - No 'map' (added protobuf 3.0). We instead represent mappings as lists +// of key-value pairs, where order does not matter and duplicates +// are not allowed. + + +// Versioning +// +// ONNX versioning is specified in docs/IR.md and elaborated on in docs/Versioning.md +// +// To be compatible with both proto2 and proto3, we will use a version number +// that is not defined by the default value but an explicit enum number. +enum Version { + // proto3 requires the first enum value to be zero. + // We add this just to appease the compiler. + _START_VERSION = 0; + // The version field is always serialized and we will use it to store the + // version that the graph is generated from. This helps us set up version + // control. + // For the IR, we are using simple numbers starting with with 0x00000001, + // which was the version we published on Oct 10, 2017. + IR_VERSION_2017_10_10 = 0x0000000000000001; + + // IR_VERSION 2 published on Oct 30, 2017 + // - Added type discriminator to AttributeProto to support proto3 users + IR_VERSION_2017_10_30 = 0x0000000000000002; + + // IR VERSION 3 published on Nov 3, 2017 + // - For operator versioning: + // - Added new message OperatorSetIdProto + // - Added opset_import in ModelProto + // - For vendor extensions, added domain in NodeProto + IR_VERSION = 0x0000000000000003; +} + +// Attributes +// +// A named attribute containing either singular float, integer, string, graph, +// and tensor values, or repeated float, integer, string, graph, and tensor values. +// An AttributeProto MUST contain the name field, and *only one* of the +// following content fields, effectively enforcing a C/C++ union equivalent. +message AttributeProto { + + // Note: this enum is structurally identical to the OpSchema::AttrType + // enum defined in schema.h. If you rev one, you likely need to rev the other. + enum AttributeType { + UNDEFINED = 0; + FLOAT = 1; + INT = 2; + STRING = 3; + TENSOR = 4; + GRAPH = 5; + + FLOATS = 6; + INTS = 7; + STRINGS = 8; + TENSORS = 9; + GRAPHS = 10; + } + + // The name field MUST be present for this version of the IR. + optional string name = 1; // namespace Attribute + + // if ref_attr_name is not empty, ref_attr_name is the attribute name in parent function. + // In this case, this AttributeProto does not contain data, and it's a reference of attribute + // in parent scope. + // NOTE: This should ONLY be used in function (sub-graph). It's invalid to be used in main graph. + optional string ref_attr_name = 21; + + // A human-readable documentation for this attribute. Markdown is allowed. + optional string doc_string = 13; + + // The type field MUST be present for this version of the IR. + // For 0.0.1 versions of the IR, this field was not defined, and + // implementations needed to use has_field hueristics to determine + // which value field was in use. For IR_VERSION 0.0.2 or later, this + // field MUST be set and match the f|i|s|t|... field in use. This + // change was made to accomodate proto3 implementations. + optional AttributeType type = 20; // discriminator that indicates which field below is in use + + // Exactly ONE of the following fields must be present for this version of the IR + optional float f = 2; // float + optional int64 i = 3; // int + optional bytes s = 4; // UTF-8 string + optional TensorProto t = 5; // tensor value + optional GraphProto g = 6; // graph + // Do not use field below, it's deprecated. + // optional ValueProto v = 12; // value - subsumes everything but graph + + repeated float floats = 7; // list of floats + repeated int64 ints = 8; // list of ints + repeated bytes strings = 9; // list of UTF-8 strings + repeated TensorProto tensors = 10; // list of tensors + repeated GraphProto graphs = 11; // list of graph +} + +// Defines information on value, including the name, the type, and +// the shape of the value. +message ValueInfoProto { + // This field MUST be present in this version of the IR. + optional string name = 1; // namespace Value + // This field MUST be present in this version of the IR. + optional TypeProto type = 2; + // A human-readable documentation for this value. Markdown is allowed. + optional string doc_string = 3; +} + +// Nodes +// +// Computation graphs are made up of a DAG of nodes, which represent what is +// commonly called a "layer" or "pipeline stage" in machine learning frameworks. +// +// For example, it can be a node of type "Conv" that takes in an image, a filter +// tensor and a bias tensor, and produces the convolved output. +message NodeProto { + repeated string input = 1; // namespace Value + repeated string output = 2; // namespace Value + + // An optional identifier for this node in a graph. + // This field MAY be absent in ths version of the IR. + optional string name = 3; // namespace Node + + // The symbolic identifier of the Operator to execute. + optional string op_type = 4; // namespace Operator + // The domain of the OperatorSet that specifies the operator named by op_type. + optional string domain = 7; // namespace Domain + + // Additional named attributes. + repeated AttributeProto attribute = 5; + + // A human-readable documentation for this node. Markdown is allowed. + optional string doc_string = 6; +} + +// Models +// +// ModelProto is a top-level file/container format for bundling a ML model and +// associating its computation graph with metadata. +// +// The semantics of the model are described by the associated GraphProto. +message ModelProto { + // The version of the IR this model targets. See Version enum above. + // This field MUST be present. + optional int64 ir_version = 1; + + // The OperatorSets this model relies on. + // All ModelProtos MUST have at least one entry that + // specifies which version of the ONNX OperatorSet is + // being imported. + // + // All nodes in the ModelProto's graph will bind against the operator + // with the same-domain/same-op_type operator with the HIGHEST version + // in the referenced operator sets. + repeated OperatorSetIdProto opset_import = 8; + + // The name of the framework or tool used to generate this model. + // This field SHOULD be present to indicate which implementation/tool/framework + // emitted the model. + optional string producer_name = 2; + + // The version of the framework or tool used to generate this model. + // This field SHOULD be present to indicate which implementation/tool/framework + // emitted the model. + optional string producer_version = 3; + + // Domain name of the model. + // We use reverse domain names as name space indicators. For example: + // `com.facebook.fair` or `com.microsoft.cognitiveservices` + // + // Together with `model_version` and GraphProto.name, this forms the unique identity of + // the graph. + optional string domain = 4; + + // The version of the graph encoded. See Version enum below. + optional int64 model_version = 5; + + // A human-readable documentation for this model. Markdown is allowed. + optional string doc_string = 6; + + // The parameterized graph that is evaluated to execute the model. + optional GraphProto graph = 7; + + // Named metadata values; keys should be distinct. + repeated StringStringEntryProto metadata_props = 14; +}; + +// StringStringEntryProto follows the pattern for cross-proto-version maps. +// See https://developers.google.com/protocol-buffers/docs/proto3#maps +message StringStringEntryProto { + optional string key = 1; + optional string value= 2; +}; + +// Graphs +// +// A graph defines the computational logic of a model and is comprised of a parameterized +// list of nodes that form a directed acyclic graph based on their inputs and outputs. +// This is the equivalent of the "network" or "graph" in many deep learning +// frameworks. +message GraphProto { + // The nodes in the graph, sorted topologically. + repeated NodeProto node = 1; + + // The name of the graph. + optional string name = 2; // namespace Graph + + // A list of named tensor values, used to specify constant inputs of the graph. + // Each TensorProto entry must have a distinct name (within the list) that + // also appears in the input list. + repeated TensorProto initializer = 5; + + // A human-readable documentation for this graph. Markdown is allowed. + optional string doc_string = 10; + + // The inputs and outputs of the graph. + repeated ValueInfoProto input = 11; + repeated ValueInfoProto output = 12; + + // Information for the values in the graph. The ValueInfoProto.name's + // must be distinct. It is optional for a value to appear in value_info list. + repeated ValueInfoProto value_info = 13; + + // DO NOT USE the following fields, they were deprecated from earlier versions. + // repeated string input = 3; + // repeated string output = 4; + // optional int64 ir_version = 6; + // optional int64 producer_version = 7; + // optional string producer_tag = 8; + // optional string domain = 9; +} + +// Tensors +// +// A serialized tensor value. +message TensorProto { + enum DataType { + UNDEFINED = 0; + // Basic types. + FLOAT = 1; // float + UINT8 = 2; // uint8_t + INT8 = 3; // int8_t + UINT16 = 4; // uint16_t + INT16 = 5; // int16_t + INT32 = 6; // int32_t + INT64 = 7; // int64_t + STRING = 8; // string + BOOL = 9; // bool + + // Advanced types + FLOAT16 = 10; + DOUBLE = 11; + UINT32 = 12; + UINT64 = 13; + COMPLEX64 = 14; // complex with float32 real and imaginary components + COMPLEX128 = 15; // complex with float64 real and imaginary components + // Future extensions go here. + } + + // The shape of the tensor. + repeated int64 dims = 1; + + // The data type of the tensor. + optional DataType data_type = 2; + + // For very large tensors, we may want to store them in chunks, in which + // case the following fields will specify the segment that is stored in + // the current TensorProto. + message Segment { + optional int64 begin = 1; + optional int64 end = 2; + } + optional Segment segment = 3; + + // Tensor content must be organized in row-major order. + // + // Depending on the data_type field, exactly one of the fields below with + // name ending in _data is used to store the elements of the tensor. + + // For float and complex64 values + // Complex64 tensors are encoded as a single array of floats, + // with the real components appearing in odd numbered positions, + // and the corresponding imaginary component apparing in the + // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i] + // is encoded as [1.0, 2.0 ,3.0 ,4.0] + // When this field is present, the data_type field MUST be FLOAT or COMPLEX64. + repeated float float_data = 4 [packed = true]; + + // For int32, uint8, int8, uint16, int16, bool, and float16 values + // float16 values must be bit-wise converted to an uint16_t prior + // to writing to the buffer. + // When this field is present, the data_type field MUST be + // INT32, INT16, INT8, UINT16, INT8, BOOL, or FLOAT16 + repeated int32 int32_data = 5 [packed = true]; + + // For strings. + // Each element of string_data is a UTF-8 encoded Unicode + // string. No trailing null, no leading BOM. The protobuf "string" + // scalar type is not used to match ML community conventions. + // When this field is present, the data_type field MUST be STRING + repeated bytes string_data = 6; + + // For int64. + // When this field is present, the data_type field MUST be INT64 + repeated int64 int64_data = 7 [packed = true]; + + // Optionally, a name for the tensor. + optional string name = 8; // namespace Value + + // A human-readable documentation for this tensor. Markdown is allowed. + optional string doc_string = 12; + + // Serializations can either use one of the fields above, or use this + // raw bytes field. The only exception is the string case, where one is + // required to store the content in the repeated bytes string_data field. + // + // When this raw_data field is used to store tensor value, elements MUST + // be stored in as fixed-width, little-endian order. + // Floating-point data types MUST be stored in IEEE 754 format. + // Complex64 elements must be written as two consecutive FLOAT values, real component first. + // Complex128 elements must be written as two consecutive DOUBLE values, real component first. + // Boolean type MUST be written one byte per tensor element (00000001 for true, 00000000 for false). + // + // Note: the advantage of specific field rather than the raw_data field is + // that in some cases (e.g. int data), protobuf does a better packing via + // variable length storage, and may lead to smaller binary footprint. + // When this field is present, the data_type field MUST NOT be STRING or UNDEFINED + optional bytes raw_data = 9; + + // For double + // Complex64 tensors are encoded as a single array of doubles, + // with the real components appearing in odd numbered positions, + // and the corresponding imaginary component apparing in the + // subsequent even numbered position. (e.g., [1.0 + 2.0i, 3.0 + 4.0i] + // is encoded as [1.0, 2.0 ,3.0 ,4.0] + // When this field is present, the data_type field MUST be DOUBLE or COMPLEX128 + repeated double double_data = 10 [packed = true]; + + // For uint64 and uint32 values + // When this field is present, the data_type field MUST be + // UINT32 or UINT64 + repeated uint64 uint64_data = 11 [packed = true]; +} + +// Defines a tensor shape. A dimension can be either an integer value +// or a symbolic variable. A symbolic variable represents an unknown +// dimension. +message TensorShapeProto { + message Dimension { + oneof value { + int64 dim_value = 1; + string dim_param = 2; // namespace Shape + }; + // Standard denotation can optionally be used to denote tensor + // dimensions with standard semantic descriptions to ensure + // that operations are applied to the correct axis of a tensor. + // Refer to https://github.com/onnx/onnx/blob/master/docs/DimensionDenotation.md#denotation-definition + // for pre-defined dimension denotations. + optional string denotation = 3; + }; + repeated Dimension dim = 1; +} + +// Types +// +// The standard ONNX data types. +message TypeProto { + + message Tensor { + // This field MUST NOT have the value of UNDEFINED + // This field MUST be present for this version of the IR. + optional TensorProto.DataType elem_type = 1; + optional TensorShapeProto shape = 2; + } + + + oneof value { + // The type of a tensor. + Tensor tensor_type = 1; + + } + + // An optional denotation can be used to denote the whole + // type with a standard semantic description as to what is + // stored inside. Refer to https://github.com/onnx/onnx/blob/master/docs/TypeDenotation.md#type-denotation-definition + // for pre-defined type denotations. + optional string denotation = 6; +} + +// Operator Sets +// +// OperatorSets are uniquely identified by a (domain, opset_version) pair. +message OperatorSetIdProto { + // The domain of the operator set being identified. + // The empty string ("") or absence of this field implies the operator + // set that is defined as part of the ONNX specification. + // This field MUST be present in this version of the IR when referring to any other operator set. + optional string domain = 1; + + // The version of the operator set being identified. + // This field MUST be present in this version of the IR. + optional int64 version = 2; +} diff --git a/modules/dnn/test/test_onnx_importer.cpp b/modules/dnn/test/test_onnx_importer.cpp new file mode 100644 index 0000000000..8ac4baebe7 --- /dev/null +++ b/modules/dnn/test/test_onnx_importer.cpp @@ -0,0 +1,344 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2018, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. + + +#include "test_precomp.hpp" +#include "npy_blob.hpp" +#include + +namespace opencv_test { namespace { + +template +static std::string _tf(TString filename) +{ + String rootFolder = "dnn/onnx/"; + return findDataFile(rootFolder + filename, false); +} + +class Test_ONNX_layers : public DNNTestLayer +{ +public: + enum Extension + { + npy, + pb + }; + + void testONNXModels(const String& basename, const Extension ext = npy, const double l1 = 0, const float lInf = 0) + { + String onnxmodel = _tf("models/" + basename + ".onnx"); + Mat inp, ref; + if (ext == npy) { + inp = blobFromNPY(_tf("data/input_" + basename + ".npy")); + ref = blobFromNPY(_tf("data/output_" + basename + ".npy")); + } + else if (ext == pb) { + inp = readTensorFromONNX(_tf("data/input_" + basename + ".pb")); + ref = readTensorFromONNX(_tf("data/output_" + basename + ".pb")); + } + else + CV_Error(Error::StsUnsupportedFormat, "Unsupported extension"); + + checkBackend(&inp, &ref); + Net net = readNetFromONNX(onnxmodel); + ASSERT_FALSE(net.empty()); + + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + net.setInput(inp); + Mat out = net.forward(); + normAssert(ref, out, "", l1 ? l1 : default_l1, lInf ? lInf : default_lInf); + } +}; + +TEST_P(Test_ONNX_layers, MaxPooling) +{ + testONNXModels("maxpooling"); + testONNXModels("two_maxpooling"); +} + +TEST_P(Test_ONNX_layers, Convolution) +{ + testONNXModels("convolution"); + testONNXModels("two_convolution"); +} + +TEST_P(Test_ONNX_layers, Dropout) +{ + testONNXModels("dropout"); +} + +TEST_P(Test_ONNX_layers, Linear) +{ + if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) + throw SkipTestException(""); + testONNXModels("linear"); +} + +TEST_P(Test_ONNX_layers, ReLU) +{ + testONNXModels("ReLU"); +} + +TEST_P(Test_ONNX_layers, MaxPooling_Sigmoid) +{ + testONNXModels("maxpooling_sigmoid"); +} + +TEST_P(Test_ONNX_layers, Concatenation) +{ + if (backend == DNN_BACKEND_INFERENCE_ENGINE && + (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD)) + throw SkipTestException(""); + testONNXModels("concatenation"); +} + +TEST_P(Test_ONNX_layers, AveragePooling) +{ + testONNXModels("average_pooling"); +} + +TEST_P(Test_ONNX_layers, BatchNormalization) +{ + testONNXModels("batch_norm"); +} + +TEST_P(Test_ONNX_layers, Multiplication) +{ + if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16 || + backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD) + throw SkipTestException(""); + testONNXModels("mul"); +} + +TEST_P(Test_ONNX_layers, Constant) +{ + testONNXModels("constant"); +} + +TEST_P(Test_ONNX_layers, MultyInputs) +{ + const String model = _tf("models/multy_inputs.onnx"); + + Net net = readNetFromONNX(model); + ASSERT_FALSE(net.empty()); + + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + Mat inp1 = blobFromNPY(_tf("data/input_multy_inputs_0.npy")); + Mat inp2 = blobFromNPY(_tf("data/input_multy_inputs_1.npy")); + Mat ref = blobFromNPY(_tf("data/output_multy_inputs.npy")); + checkBackend(&inp1, &ref); + + net.setInput(inp1, "0"); + net.setInput(inp2, "1"); + Mat out = net.forward(); + + normAssert(ref, out, "", default_l1, default_lInf); +} + + +INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets()); + +class Test_ONNX_nets : public Test_ONNX_layers {}; +TEST_P(Test_ONNX_nets, Alexnet) +{ + const String model = _tf("models/alexnet.onnx"); + + Net net = readNetFromONNX(model); + ASSERT_FALSE(net.empty()); + + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + Mat inp = imread(_tf("../grace_hopper_227.png")); + Mat ref = blobFromNPY(_tf("../caffe_alexnet_prob.npy")); + checkBackend(&inp, &ref); + + net.setInput(blobFromImage(inp, 1.0f, Size(227, 227), Scalar(), false)); + ASSERT_FALSE(net.empty()); + Mat out = net.forward(); + + normAssert(out, ref, "", default_l1, default_lInf); +} + +TEST_P(Test_ONNX_nets, Squeezenet) +{ + testONNXModels("squeezenet", pb); +} + +TEST_P(Test_ONNX_nets, Googlenet) +{ + if (backend == DNN_BACKEND_INFERENCE_ENGINE) + throw SkipTestException(""); + + const String model = _tf("models/googlenet.onnx"); + + Net net = readNetFromONNX(model); + ASSERT_FALSE(net.empty()); + + net.setPreferableBackend(backend); + net.setPreferableTarget(target); + + std::vector images; + images.push_back( imread(_tf("../googlenet_0.png")) ); + images.push_back( imread(_tf("../googlenet_1.png")) ); + Mat inp = blobFromImages(images, 1.0f, Size(), Scalar(), false); + Mat ref = blobFromNPY(_tf("../googlenet_prob.npy")); + checkBackend(&inp, &ref); + + net.setInput(inp); + ASSERT_FALSE(net.empty()); + Mat out = net.forward(); + + normAssert(ref, out, "", default_l1, default_lInf); +} + +TEST_P(Test_ONNX_nets, CaffeNet) +{ + testONNXModels("caffenet", pb); +} + +TEST_P(Test_ONNX_nets, RCNN_ILSVRC13) +{ + testONNXModels("rcnn_ilsvrc13", pb); +} + +TEST_P(Test_ONNX_nets, VGG16) +{ + double l1 = default_l1; + double lInf = default_lInf; + // output range: [-69; 72] + if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) { + l1 = 0.087; + lInf = 0.585; + } + else if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL) { + lInf = 1.2e-4; + } + testONNXModels("vgg16", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, VGG16_bn) +{ + double l1 = default_l1; + double lInf = default_lInf; + // output range: [-16; 27] + if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) { + l1 = 0.0086; + lInf = 0.037; + } + else if (backend == DNN_BACKEND_INFERENCE_ENGINE && + (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD)) { + l1 = 0.031; + lInf = 0.2; + } + testONNXModels("vgg16-bn", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, ZFNet) +{ + testONNXModels("zfnet512", pb); +} + +TEST_P(Test_ONNX_nets, ResNet18v1) +{ + // output range: [-16; 22] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.022 : default_l1; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.12 : default_lInf; + testONNXModels("resnet18v1", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, ResNet50v1) +{ + // output range: [-67; 75] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.6 : 1.25e-5; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.51 : 1.2e-4; + testONNXModels("resnet50v1", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, ResNet101_DUC_HDC) +{ + if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL + || target == DNN_TARGET_MYRIAD) { + throw SkipTestException(""); + } + testONNXModels("resnet101_duc_hdc", pb); +} + +TEST_P(Test_ONNX_nets, TinyYolov2) +{ + if (cvtest::skipUnstableTests || + backend == DNN_BACKEND_INFERENCE_ENGINE && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)) { + throw SkipTestException(""); + } + // output range: [-11; 8] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.017 : default_l1; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.14 : default_lInf; + testONNXModels("tiny_yolo2", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, CNN_MNIST) +{ + // output range: [-1952; 6574] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 3.82 : 4.3e-4; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 13.5 : 1e-3; + + testONNXModels("cnn_mnist", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, MobileNet_v2) +{ + // output range: [-166; 317] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.38 : 7e-5; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 2.87 : 5e-4; + testONNXModels("mobilenetv2", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, LResNet100E_IR) +{ + if (backend == DNN_BACKEND_INFERENCE_ENGINE && + (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD)) + throw SkipTestException(""); + + double l1 = default_l1; + double lInf = default_lInf; + // output range: [-3; 3] + if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) { + l1 = 0.009; + lInf = 0.035; + } + testONNXModels("LResNet100E_IR", pb, l1, lInf); +} + +TEST_P(Test_ONNX_nets, Emotion_ferplus) +{ + testONNXModels("emotion_ferplus", pb); +} + +TEST_P(Test_ONNX_nets, Inception_v2) +{ + if (backend == DNN_BACKEND_INFERENCE_ENGINE) + throw SkipTestException(""); + + testONNXModels("inception_v2", pb); +} + +TEST_P(Test_ONNX_nets, DenseNet121) +{ + // output range: [-87; 138] + const double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.12 : 1.88e-5; + const double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.74 : 1.23e-4; + testONNXModels("densenet121", pb, l1, lInf); +} + + +INSTANTIATE_TEST_CASE_P(/**/, Test_ONNX_nets, dnnBackendsAndTargets()); + +}} // namespace -- GitLab