diff --git a/meson_options.txt b/meson_options.txt index ee3119b4e..7fc934b05 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -13,6 +13,7 @@ option('enable-profile', type: 'boolean', value: false) option('enable-trace', type: 'boolean', value: false) option('enable-debug', type: 'boolean', value: false) option('enable-tflite-interpreter', type: 'boolean', value: true) +option('enable-onnx-interpreter', type: 'boolean', value: false) option('enable-memory-swap', type: 'boolean', value: false) option('memory-swap-path', type: 'string', value: '') option('test-timeout', type: 'integer', value: 60) diff --git a/nntrainer/compiler/meson.build b/nntrainer/compiler/meson.build index cd0fe644d..a6ecdf97c 100644 --- a/nntrainer/compiler/meson.build +++ b/nntrainer/compiler/meson.build @@ -16,6 +16,15 @@ compiler_headers = [ 'compiler_fwd.h' ] +if get_option('enable-onnx-interpreter') + protobuf_dep = dependency('protobuf', required: true) + nntrainer_base_deps += protobuf_dep + + compiler_sources += [ + 'onnx.pb.cc', + ] +endif + if get_option('enable-tflite-interpreter') if not tflite_dep.found() error('Tensorflow2-Lite dependency not found') diff --git a/nntrainer/compiler/onnx.pb.cc b/nntrainer/compiler/onnx.pb.cc new file mode 100644 index 000000000..028856acb --- /dev/null +++ b/nntrainer/compiler/onnx.pb.cc @@ -0,0 +1,9060 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: onnx.proto + +#include "onnx.pb.h" + +#include + +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG + +namespace _pb = ::PROTOBUF_NAMESPACE_ID; +namespace _pbi = _pb::internal; + +namespace onnx { +PROTOBUF_CONSTEXPR AttributeProto::AttributeProto(::_pbi::ConstantInitialized) : + floats_(), + ints_(), + strings_(), + tensors_(), + graphs_(), + type_protos_(), + sparse_tensors_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + s_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + ref_attr_name_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + t_(nullptr), + g_(nullptr), + tp_(nullptr), + sparse_tensor_(nullptr), + i_(int64_t{0}), + f_(0), + type_(0) {} +struct AttributeProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR AttributeProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~AttributeProtoDefaultTypeInternal() {} + union { + AttributeProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttributeProtoDefaultTypeInternal + _AttributeProto_default_instance_; +PROTOBUF_CONSTEXPR ValueInfoProto::ValueInfoProto(::_pbi::ConstantInitialized) : + metadata_props_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + type_(nullptr) {} +struct ValueInfoProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ValueInfoProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~ValueInfoProtoDefaultTypeInternal() {} + union { + ValueInfoProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueInfoProtoDefaultTypeInternal + _ValueInfoProto_default_instance_; +PROTOBUF_CONSTEXPR NodeProto::NodeProto(::_pbi::ConstantInitialized) : + input_(), + output_(), + attribute_(), + metadata_props_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + op_type_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + domain_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + overload_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}) {} +struct NodeProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR NodeProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~NodeProtoDefaultTypeInternal() {} + union { + NodeProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NodeProtoDefaultTypeInternal + _NodeProto_default_instance_; +PROTOBUF_CONSTEXPR +TrainingInfoProto::TrainingInfoProto(::_pbi::ConstantInitialized) : + initialization_binding_(), + update_binding_(), + initialization_(nullptr), + algorithm_(nullptr) {} +struct TrainingInfoProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR TrainingInfoProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TrainingInfoProtoDefaultTypeInternal() {} + union { + TrainingInfoProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrainingInfoProtoDefaultTypeInternal + _TrainingInfoProto_default_instance_; +PROTOBUF_CONSTEXPR ModelProto::ModelProto(::_pbi::ConstantInitialized) : + opset_import_(), + metadata_props_(), + training_info_(), + functions_(), + producer_name_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + producer_version_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + domain_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + graph_(nullptr), + ir_version_(int64_t{0}), + model_version_(int64_t{0}) {} +struct ModelProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR ModelProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~ModelProtoDefaultTypeInternal() {} + union { + ModelProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ModelProtoDefaultTypeInternal + _ModelProto_default_instance_; +PROTOBUF_CONSTEXPR +StringStringEntryProto::StringStringEntryProto(::_pbi::ConstantInitialized) : + key_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + value_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}) {} +struct StringStringEntryProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR StringStringEntryProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~StringStringEntryProtoDefaultTypeInternal() {} + union { + StringStringEntryProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StringStringEntryProtoDefaultTypeInternal + _StringStringEntryProto_default_instance_; +PROTOBUF_CONSTEXPR +TensorAnnotation::TensorAnnotation(::_pbi::ConstantInitialized) : + quant_parameter_tensor_names_(), + tensor_name_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}) {} +struct TensorAnnotationDefaultTypeInternal { + PROTOBUF_CONSTEXPR TensorAnnotationDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TensorAnnotationDefaultTypeInternal() {} + union { + TensorAnnotation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TensorAnnotationDefaultTypeInternal + _TensorAnnotation_default_instance_; +PROTOBUF_CONSTEXPR GraphProto::GraphProto(::_pbi::ConstantInitialized) : + node_(), + initializer_(), + input_(), + output_(), + value_info_(), + quantization_annotation_(), + sparse_initializer_(), + metadata_props_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}) {} +struct GraphProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR GraphProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~GraphProtoDefaultTypeInternal() {} + union { + GraphProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphProtoDefaultTypeInternal + _GraphProto_default_instance_; +PROTOBUF_CONSTEXPR +TensorProto_Segment::TensorProto_Segment(::_pbi::ConstantInitialized) : + begin_(int64_t{0}), end_(int64_t{0}) {} +struct TensorProto_SegmentDefaultTypeInternal { + PROTOBUF_CONSTEXPR TensorProto_SegmentDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TensorProto_SegmentDefaultTypeInternal() {} + union { + TensorProto_Segment _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TensorProto_SegmentDefaultTypeInternal + _TensorProto_Segment_default_instance_; +PROTOBUF_CONSTEXPR TensorProto::TensorProto(::_pbi::ConstantInitialized) : + dims_(), + float_data_(), + int32_data_(), + _int32_data_cached_byte_size_(0), + string_data_(), + int64_data_(), + _int64_data_cached_byte_size_(0), + double_data_(), + uint64_data_(), + _uint64_data_cached_byte_size_(0), + external_data_(), + metadata_props_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + raw_data_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + segment_(nullptr), + data_type_(0), + data_location_(0) {} +struct TensorProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR TensorProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TensorProtoDefaultTypeInternal() {} + union { + TensorProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TensorProtoDefaultTypeInternal + _TensorProto_default_instance_; +PROTOBUF_CONSTEXPR +SparseTensorProto::SparseTensorProto(::_pbi::ConstantInitialized) : + dims_(), values_(nullptr), indices_(nullptr) {} +struct SparseTensorProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR SparseTensorProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~SparseTensorProtoDefaultTypeInternal() {} + union { + SparseTensorProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SparseTensorProtoDefaultTypeInternal + _SparseTensorProto_default_instance_; +PROTOBUF_CONSTEXPR TensorShapeProto_Dimension::TensorShapeProto_Dimension( + ::_pbi::ConstantInitialized) : + denotation_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + _oneof_case_{} {} +struct TensorShapeProto_DimensionDefaultTypeInternal { + PROTOBUF_CONSTEXPR TensorShapeProto_DimensionDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TensorShapeProto_DimensionDefaultTypeInternal() {} + union { + TensorShapeProto_Dimension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 + TensorShapeProto_DimensionDefaultTypeInternal + _TensorShapeProto_Dimension_default_instance_; +PROTOBUF_CONSTEXPR +TensorShapeProto::TensorShapeProto(::_pbi::ConstantInitialized) : dim_() {} +struct TensorShapeProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR TensorShapeProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TensorShapeProtoDefaultTypeInternal() {} + union { + TensorShapeProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TensorShapeProtoDefaultTypeInternal + _TensorShapeProto_default_instance_; +PROTOBUF_CONSTEXPR +TypeProto_Tensor::TypeProto_Tensor(::_pbi::ConstantInitialized) : + shape_(nullptr), elem_type_(0) {} +struct TypeProto_TensorDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProto_TensorDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProto_TensorDefaultTypeInternal() {} + union { + TypeProto_Tensor _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProto_TensorDefaultTypeInternal + _TypeProto_Tensor_default_instance_; +PROTOBUF_CONSTEXPR +TypeProto_Sequence::TypeProto_Sequence(::_pbi::ConstantInitialized) : + elem_type_(nullptr) {} +struct TypeProto_SequenceDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProto_SequenceDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProto_SequenceDefaultTypeInternal() {} + union { + TypeProto_Sequence _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProto_SequenceDefaultTypeInternal + _TypeProto_Sequence_default_instance_; +PROTOBUF_CONSTEXPR TypeProto_Map::TypeProto_Map(::_pbi::ConstantInitialized) : + value_type_(nullptr), key_type_(0) {} +struct TypeProto_MapDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProto_MapDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProto_MapDefaultTypeInternal() {} + union { + TypeProto_Map _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProto_MapDefaultTypeInternal + _TypeProto_Map_default_instance_; +PROTOBUF_CONSTEXPR +TypeProto_Optional::TypeProto_Optional(::_pbi::ConstantInitialized) : + elem_type_(nullptr) {} +struct TypeProto_OptionalDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProto_OptionalDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProto_OptionalDefaultTypeInternal() {} + union { + TypeProto_Optional _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProto_OptionalDefaultTypeInternal + _TypeProto_Optional_default_instance_; +PROTOBUF_CONSTEXPR +TypeProto_SparseTensor::TypeProto_SparseTensor(::_pbi::ConstantInitialized) : + shape_(nullptr), elem_type_(0) {} +struct TypeProto_SparseTensorDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProto_SparseTensorDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProto_SparseTensorDefaultTypeInternal() {} + union { + TypeProto_SparseTensor _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProto_SparseTensorDefaultTypeInternal + _TypeProto_SparseTensor_default_instance_; +PROTOBUF_CONSTEXPR TypeProto::TypeProto(::_pbi::ConstantInitialized) : + denotation_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + _oneof_case_{} {} +struct TypeProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR TypeProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~TypeProtoDefaultTypeInternal() {} + union { + TypeProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TypeProtoDefaultTypeInternal + _TypeProto_default_instance_; +PROTOBUF_CONSTEXPR +OperatorSetIdProto::OperatorSetIdProto(::_pbi::ConstantInitialized) : + domain_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + version_(int64_t{0}) {} +struct OperatorSetIdProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR OperatorSetIdProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~OperatorSetIdProtoDefaultTypeInternal() {} + union { + OperatorSetIdProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperatorSetIdProtoDefaultTypeInternal + _OperatorSetIdProto_default_instance_; +PROTOBUF_CONSTEXPR FunctionProto::FunctionProto(::_pbi::ConstantInitialized) : + input_(), + output_(), + attribute_(), + node_(), + opset_import_(), + attribute_proto_(), + value_info_(), + metadata_props_(), + name_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + doc_string_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}), + domain_(&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}), + overload_(&::_pbi::fixed_address_empty_string, + ::_pbi::ConstantInitialized{}) {} +struct FunctionProtoDefaultTypeInternal { + PROTOBUF_CONSTEXPR FunctionProtoDefaultTypeInternal() : + _instance(::_pbi::ConstantInitialized{}) {} + ~FunctionProtoDefaultTypeInternal() {} + union { + FunctionProto _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FunctionProtoDefaultTypeInternal + _FunctionProto_default_instance_; +} // namespace onnx +namespace onnx { +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: + case 11: + case 12: + case 13: + case 14: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed + AttributeProto_AttributeType_strings[15] = {}; + +static const char AttributeProto_AttributeType_names[] = "FLOAT" + "FLOATS" + "GRAPH" + "GRAPHS" + "INT" + "INTS" + "SPARSE_TENSOR" + "SPARSE_TENSORS" + "STRING" + "STRINGS" + "TENSOR" + "TENSORS" + "TYPE_PROTO" + "TYPE_PROTOS" + "UNDEFINED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry + AttributeProto_AttributeType_entries[] = { + {{AttributeProto_AttributeType_names + 0, 5}, 1}, + {{AttributeProto_AttributeType_names + 5, 6}, 6}, + {{AttributeProto_AttributeType_names + 11, 5}, 5}, + {{AttributeProto_AttributeType_names + 16, 6}, 10}, + {{AttributeProto_AttributeType_names + 22, 3}, 2}, + {{AttributeProto_AttributeType_names + 25, 4}, 7}, + {{AttributeProto_AttributeType_names + 29, 13}, 11}, + {{AttributeProto_AttributeType_names + 42, 14}, 12}, + {{AttributeProto_AttributeType_names + 56, 6}, 3}, + {{AttributeProto_AttributeType_names + 62, 7}, 8}, + {{AttributeProto_AttributeType_names + 69, 6}, 4}, + {{AttributeProto_AttributeType_names + 75, 7}, 9}, + {{AttributeProto_AttributeType_names + 82, 10}, 13}, + {{AttributeProto_AttributeType_names + 92, 11}, 14}, + {{AttributeProto_AttributeType_names + 103, 9}, 0}, +}; + +static const int AttributeProto_AttributeType_entries_by_number[] = { + 14, // 0 -> UNDEFINED + 0, // 1 -> FLOAT + 4, // 2 -> INT + 8, // 3 -> STRING + 10, // 4 -> TENSOR + 2, // 5 -> GRAPH + 1, // 6 -> FLOATS + 5, // 7 -> INTS + 9, // 8 -> STRINGS + 11, // 9 -> TENSORS + 3, // 10 -> GRAPHS + 6, // 11 -> SPARSE_TENSOR + 7, // 12 -> SPARSE_TENSORS + 12, // 13 -> TYPE_PROTO + 13, // 14 -> TYPE_PROTOS +}; + +const std::string & +AttributeProto_AttributeType_Name(AttributeProto_AttributeType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + AttributeProto_AttributeType_entries, + AttributeProto_AttributeType_entries_by_number, 15, + AttributeProto_AttributeType_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + AttributeProto_AttributeType_entries, + AttributeProto_AttributeType_entries_by_number, 15, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() + : AttributeProto_AttributeType_strings[idx].get(); +} +bool AttributeProto_AttributeType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AttributeProto_AttributeType *value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + AttributeProto_AttributeType_entries, 15, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr AttributeProto_AttributeType AttributeProto::UNDEFINED; +constexpr AttributeProto_AttributeType AttributeProto::FLOAT; +constexpr AttributeProto_AttributeType AttributeProto::INT; +constexpr AttributeProto_AttributeType AttributeProto::STRING; +constexpr AttributeProto_AttributeType AttributeProto::TENSOR; +constexpr AttributeProto_AttributeType AttributeProto::GRAPH; +constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSOR; +constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTO; +constexpr AttributeProto_AttributeType AttributeProto::FLOATS; +constexpr AttributeProto_AttributeType AttributeProto::INTS; +constexpr AttributeProto_AttributeType AttributeProto::STRINGS; +constexpr AttributeProto_AttributeType AttributeProto::TENSORS; +constexpr AttributeProto_AttributeType AttributeProto::GRAPHS; +constexpr AttributeProto_AttributeType AttributeProto::SPARSE_TENSORS; +constexpr AttributeProto_AttributeType AttributeProto::TYPE_PROTOS; +constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MIN; +constexpr AttributeProto_AttributeType AttributeProto::AttributeType_MAX; +constexpr int AttributeProto::AttributeType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && + // _MSC_VER < 1912)) +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: + case 16: + case 17: + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed + TensorProto_DataType_strings[24] = {}; + +static const char TensorProto_DataType_names[] = "BFLOAT16" + "BOOL" + "COMPLEX128" + "COMPLEX64" + "DOUBLE" + "FLOAT" + "FLOAT16" + "FLOAT4E2M1" + "FLOAT8E4M3FN" + "FLOAT8E4M3FNUZ" + "FLOAT8E5M2" + "FLOAT8E5M2FNUZ" + "INT16" + "INT32" + "INT4" + "INT64" + "INT8" + "STRING" + "UINT16" + "UINT32" + "UINT4" + "UINT64" + "UINT8" + "UNDEFINED"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry + TensorProto_DataType_entries[] = { + {{TensorProto_DataType_names + 0, 8}, 16}, + {{TensorProto_DataType_names + 8, 4}, 9}, + {{TensorProto_DataType_names + 12, 10}, 15}, + {{TensorProto_DataType_names + 22, 9}, 14}, + {{TensorProto_DataType_names + 31, 6}, 11}, + {{TensorProto_DataType_names + 37, 5}, 1}, + {{TensorProto_DataType_names + 42, 7}, 10}, + {{TensorProto_DataType_names + 49, 10}, 23}, + {{TensorProto_DataType_names + 59, 12}, 17}, + {{TensorProto_DataType_names + 71, 14}, 18}, + {{TensorProto_DataType_names + 85, 10}, 19}, + {{TensorProto_DataType_names + 95, 14}, 20}, + {{TensorProto_DataType_names + 109, 5}, 5}, + {{TensorProto_DataType_names + 114, 5}, 6}, + {{TensorProto_DataType_names + 119, 4}, 22}, + {{TensorProto_DataType_names + 123, 5}, 7}, + {{TensorProto_DataType_names + 128, 4}, 3}, + {{TensorProto_DataType_names + 132, 6}, 8}, + {{TensorProto_DataType_names + 138, 6}, 4}, + {{TensorProto_DataType_names + 144, 6}, 12}, + {{TensorProto_DataType_names + 150, 5}, 21}, + {{TensorProto_DataType_names + 155, 6}, 13}, + {{TensorProto_DataType_names + 161, 5}, 2}, + {{TensorProto_DataType_names + 166, 9}, 0}, +}; + +static const int TensorProto_DataType_entries_by_number[] = { + 23, // 0 -> UNDEFINED + 5, // 1 -> FLOAT + 22, // 2 -> UINT8 + 16, // 3 -> INT8 + 18, // 4 -> UINT16 + 12, // 5 -> INT16 + 13, // 6 -> INT32 + 15, // 7 -> INT64 + 17, // 8 -> STRING + 1, // 9 -> BOOL + 6, // 10 -> FLOAT16 + 4, // 11 -> DOUBLE + 19, // 12 -> UINT32 + 21, // 13 -> UINT64 + 3, // 14 -> COMPLEX64 + 2, // 15 -> COMPLEX128 + 0, // 16 -> BFLOAT16 + 8, // 17 -> FLOAT8E4M3FN + 9, // 18 -> FLOAT8E4M3FNUZ + 10, // 19 -> FLOAT8E5M2 + 11, // 20 -> FLOAT8E5M2FNUZ + 20, // 21 -> UINT4 + 14, // 22 -> INT4 + 7, // 23 -> FLOAT4E2M1 +}; + +const std::string &TensorProto_DataType_Name(TensorProto_DataType value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + TensorProto_DataType_entries, TensorProto_DataType_entries_by_number, 24, + TensorProto_DataType_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + TensorProto_DataType_entries, TensorProto_DataType_entries_by_number, 24, + value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() + : TensorProto_DataType_strings[idx].get(); +} +bool TensorProto_DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + TensorProto_DataType *value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + TensorProto_DataType_entries, 24, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr TensorProto_DataType TensorProto::UNDEFINED; +constexpr TensorProto_DataType TensorProto::FLOAT; +constexpr TensorProto_DataType TensorProto::UINT8; +constexpr TensorProto_DataType TensorProto::INT8; +constexpr TensorProto_DataType TensorProto::UINT16; +constexpr TensorProto_DataType TensorProto::INT16; +constexpr TensorProto_DataType TensorProto::INT32; +constexpr TensorProto_DataType TensorProto::INT64; +constexpr TensorProto_DataType TensorProto::STRING; +constexpr TensorProto_DataType TensorProto::BOOL; +constexpr TensorProto_DataType TensorProto::FLOAT16; +constexpr TensorProto_DataType TensorProto::DOUBLE; +constexpr TensorProto_DataType TensorProto::UINT32; +constexpr TensorProto_DataType TensorProto::UINT64; +constexpr TensorProto_DataType TensorProto::COMPLEX64; +constexpr TensorProto_DataType TensorProto::COMPLEX128; +constexpr TensorProto_DataType TensorProto::BFLOAT16; +constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FN; +constexpr TensorProto_DataType TensorProto::FLOAT8E4M3FNUZ; +constexpr TensorProto_DataType TensorProto::FLOAT8E5M2; +constexpr TensorProto_DataType TensorProto::FLOAT8E5M2FNUZ; +constexpr TensorProto_DataType TensorProto::UINT4; +constexpr TensorProto_DataType TensorProto::INT4; +constexpr TensorProto_DataType TensorProto::FLOAT4E2M1; +constexpr TensorProto_DataType TensorProto::DataType_MIN; +constexpr TensorProto_DataType TensorProto::DataType_MAX; +constexpr int TensorProto::DataType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && + // _MSC_VER < 1912)) +bool TensorProto_DataLocation_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed + TensorProto_DataLocation_strings[2] = {}; + +static const char TensorProto_DataLocation_names[] = "DEFAULT" + "EXTERNAL"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry + TensorProto_DataLocation_entries[] = { + {{TensorProto_DataLocation_names + 0, 7}, 0}, + {{TensorProto_DataLocation_names + 7, 8}, 1}, +}; + +static const int TensorProto_DataLocation_entries_by_number[] = { + 0, // 0 -> DEFAULT + 1, // 1 -> EXTERNAL +}; + +const std::string & +TensorProto_DataLocation_Name(TensorProto_DataLocation value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + TensorProto_DataLocation_entries, + TensorProto_DataLocation_entries_by_number, 2, + TensorProto_DataLocation_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + TensorProto_DataLocation_entries, + TensorProto_DataLocation_entries_by_number, 2, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() + : TensorProto_DataLocation_strings[idx].get(); +} +bool TensorProto_DataLocation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + TensorProto_DataLocation *value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + TensorProto_DataLocation_entries, 2, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +#if (__cplusplus < 201703) && \ + (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) +constexpr TensorProto_DataLocation TensorProto::DEFAULT; +constexpr TensorProto_DataLocation TensorProto::EXTERNAL; +constexpr TensorProto_DataLocation TensorProto::DataLocation_MIN; +constexpr TensorProto_DataLocation TensorProto::DataLocation_MAX; +constexpr int TensorProto::DataLocation_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && + // _MSC_VER < 1912)) +bool Version_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: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed + Version_strings[12] = {}; + +static const char Version_names[] = "IR_VERSION" + "IR_VERSION_2017_10_10" + "IR_VERSION_2017_10_30" + "IR_VERSION_2017_11_3" + "IR_VERSION_2019_1_22" + "IR_VERSION_2019_3_18" + "IR_VERSION_2019_9_19" + "IR_VERSION_2020_5_8" + "IR_VERSION_2021_7_30" + "IR_VERSION_2023_5_5" + "IR_VERSION_2024_3_25" + "_START_VERSION"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry Version_entries[] = { + {{Version_names + 0, 10}, 11}, {{Version_names + 10, 21}, 1}, + {{Version_names + 31, 21}, 2}, {{Version_names + 52, 20}, 3}, + {{Version_names + 72, 20}, 4}, {{Version_names + 92, 20}, 5}, + {{Version_names + 112, 20}, 6}, {{Version_names + 132, 19}, 7}, + {{Version_names + 151, 20}, 8}, {{Version_names + 171, 19}, 9}, + {{Version_names + 190, 20}, 10}, {{Version_names + 210, 14}, 0}, +}; + +static const int Version_entries_by_number[] = { + 11, // 0 -> _START_VERSION + 1, // 1 -> IR_VERSION_2017_10_10 + 2, // 2 -> IR_VERSION_2017_10_30 + 3, // 3 -> IR_VERSION_2017_11_3 + 4, // 4 -> IR_VERSION_2019_1_22 + 5, // 5 -> IR_VERSION_2019_3_18 + 6, // 6 -> IR_VERSION_2019_9_19 + 7, // 7 -> IR_VERSION_2020_5_8 + 8, // 8 -> IR_VERSION_2021_7_30 + 9, // 9 -> IR_VERSION_2023_5_5 + 10, // 10 -> IR_VERSION_2024_3_25 + 0, // 11 -> IR_VERSION +}; + +const std::string &Version_Name(Version value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + Version_entries, Version_entries_by_number, 12, Version_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + Version_entries, Version_entries_by_number, 12, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() + : Version_strings[idx].get(); +} +bool Version_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Version *value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + Version_entries, 12, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} +bool OperatorStatus_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed + OperatorStatus_strings[2] = {}; + +static const char OperatorStatus_names[] = "EXPERIMENTAL" + "STABLE"; + +static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry + OperatorStatus_entries[] = { + {{OperatorStatus_names + 0, 12}, 0}, + {{OperatorStatus_names + 12, 6}, 1}, +}; + +static const int OperatorStatus_entries_by_number[] = { + 0, // 0 -> EXPERIMENTAL + 1, // 1 -> STABLE +}; + +const std::string &OperatorStatus_Name(OperatorStatus value) { + static const bool dummy = + ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings( + OperatorStatus_entries, OperatorStatus_entries_by_number, 2, + OperatorStatus_strings); + (void)dummy; + int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName( + OperatorStatus_entries, OperatorStatus_entries_by_number, 2, value); + return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() + : OperatorStatus_strings[idx].get(); +} +bool OperatorStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OperatorStatus *value) { + int int_value; + bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue( + OperatorStatus_entries, 2, name, &int_value); + if (success) { + *value = static_cast(int_value); + } + return success; +} + +// =================================================================== + +class AttributeProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_ref_attr_name(HasBits *has_bits) { (*has_bits)[0] |= 8u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_type(HasBits *has_bits) { (*has_bits)[0] |= 1024u; } + static void set_has_f(HasBits *has_bits) { (*has_bits)[0] |= 512u; } + static void set_has_i(HasBits *has_bits) { (*has_bits)[0] |= 256u; } + static void set_has_s(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static const ::onnx::TensorProto &t(const AttributeProto *msg); + static void set_has_t(HasBits *has_bits) { (*has_bits)[0] |= 16u; } + static const ::onnx::GraphProto &g(const AttributeProto *msg); + static void set_has_g(HasBits *has_bits) { (*has_bits)[0] |= 32u; } + static const ::onnx::SparseTensorProto & + sparse_tensor(const AttributeProto *msg); + static void set_has_sparse_tensor(HasBits *has_bits) { + (*has_bits)[0] |= 128u; + } + static const ::onnx::TypeProto &tp(const AttributeProto *msg); + static void set_has_tp(HasBits *has_bits) { (*has_bits)[0] |= 64u; } +}; + +const ::onnx::TensorProto & +AttributeProto::_Internal::t(const AttributeProto *msg) { + return *msg->t_; +} +const ::onnx::GraphProto & +AttributeProto::_Internal::g(const AttributeProto *msg) { + return *msg->g_; +} +const ::onnx::SparseTensorProto & +AttributeProto::_Internal::sparse_tensor(const AttributeProto *msg) { + return *msg->sparse_tensor_; +} +const ::onnx::TypeProto & +AttributeProto::_Internal::tp(const AttributeProto *msg) { + return *msg->tp_; +} +AttributeProto::AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + floats_(arena), + ints_(arena), + strings_(arena), + tensors_(arena), + graphs_(arena), + type_protos_(arena), + sparse_tensors_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.AttributeProto) +} +AttributeProto::AttributeProto(const AttributeProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + floats_(from.floats_), + ints_(from.ints_), + strings_(from.strings_), + tensors_(from.tensors_), + graphs_(from.graphs_), + type_protos_(from.type_protos_), + sparse_tensors_(from.sparse_tensors_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + s_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + s_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_s()) { + s_.Set(from._internal_s(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + ref_attr_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ref_attr_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_ref_attr_name()) { + ref_attr_name_.Set(from._internal_ref_attr_name(), GetArenaForAllocation()); + } + if (from._internal_has_t()) { + t_ = new ::onnx::TensorProto(*from.t_); + } else { + t_ = nullptr; + } + if (from._internal_has_g()) { + g_ = new ::onnx::GraphProto(*from.g_); + } else { + g_ = nullptr; + } + if (from._internal_has_tp()) { + tp_ = new ::onnx::TypeProto(*from.tp_); + } else { + tp_ = nullptr; + } + if (from._internal_has_sparse_tensor()) { + sparse_tensor_ = new ::onnx::SparseTensorProto(*from.sparse_tensor_); + } else { + sparse_tensor_ = nullptr; + } + ::memcpy(&i_, &from.i_, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&i_)) + + sizeof(type_)); + // @@protoc_insertion_point(copy_constructor:onnx.AttributeProto) +} + +inline void AttributeProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + s_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + s_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + ref_attr_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + ref_attr_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&t_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&t_)) + + sizeof(type_)); +} + +AttributeProto::~AttributeProto() { + // @@protoc_insertion_point(destructor:onnx.AttributeProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void AttributeProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + s_.Destroy(); + doc_string_.Destroy(); + ref_attr_name_.Destroy(); + if (this != internal_default_instance()) + delete t_; + if (this != internal_default_instance()) + delete g_; + if (this != internal_default_instance()) + delete tp_; + if (this != internal_default_instance()) + delete sparse_tensor_; +} + +void AttributeProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void AttributeProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.AttributeProto) + uint32_t 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(); + type_protos_.Clear(); + sparse_tensors_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + s_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + ref_attr_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(t_ != nullptr); + t_->Clear(); + } + if (cached_has_bits & 0x00000020u) { + GOOGLE_DCHECK(g_ != nullptr); + g_->Clear(); + } + if (cached_has_bits & 0x00000040u) { + GOOGLE_DCHECK(tp_ != nullptr); + tp_->Clear(); + } + if (cached_has_bits & 0x00000080u) { + GOOGLE_DCHECK(sparse_tensor_ != nullptr); + sparse_tensor_->Clear(); + } + } + if (cached_has_bits & 0x00000700u) { + ::memset(&i_, 0, + static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&i_)) + + sizeof(type_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *AttributeProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional float f = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 21)) { + _Internal::set_has_f(&has_bits); + f_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // optional int64 i = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _Internal::set_has_i(&has_bits); + i_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes s = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_s(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorProto t = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_t(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.GraphProto g = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_g(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float floats = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 61)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_floats( + ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<61>(ptr)); + } else if (static_cast(tag) == 58) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser( + _internal_mutable_floats(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int64 ints = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_ints( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<64>(ptr)); + } else if (static_cast(tag) == 66) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser( + _internal_mutable_ints(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated bytes strings = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_strings(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.TensorProto tensors = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_tensors(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.GraphProto graphs = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_graphs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); + } else + goto handle_unusual; + continue; + // optional string doc_string = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TypeProto tp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_tp(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.TypeProto type_protos = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_type_protos(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); + } else + goto handle_unusual; + continue; + // optional .onnx.AttributeProto.AttributeType type = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 160)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE( + ::onnx::AttributeProto_AttributeType_IsValid(val))) { + _internal_set_type( + static_cast<::onnx::AttributeProto_AttributeType>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint( + 20, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // optional string ref_attr_name = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { + auto str = _internal_mutable_ref_attr_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.SparseTensorProto sparse_tensor = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.SparseTensorProto sparse_tensors = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_sparse_tensors(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<186>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *AttributeProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.AttributeProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(1, this->_internal_name(), target); + } + + // optional float f = 2; + if (cached_has_bits & 0x00000200u) { + target = stream->EnsureSpace(target); + target = + ::_pbi::WireFormatLite::WriteFloatToArray(2, this->_internal_f(), target); + } + + // optional int64 i = 3; + if (cached_has_bits & 0x00000100u) { + target = stream->EnsureSpace(target); + target = + ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_i(), target); + } + + // optional bytes s = 4; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteBytesMaybeAliased(4, this->_internal_s(), target); + } + + // optional .onnx.TensorProto t = 5; + if (cached_has_bits & 0x00000010u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 5, _Internal::t(this), _Internal::t(this).GetCachedSize(), target, + stream); + } + + // optional .onnx.GraphProto g = 6; + if (cached_has_bits & 0x00000020u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 6, _Internal::g(this), _Internal::g(this).GetCachedSize(), target, + stream); + } + + // repeated float floats = 7; + for (int i = 0, n = this->_internal_floats_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 7, this->_internal_floats(i), target); + } + + // repeated int64 ints = 8; + for (int i = 0, n = this->_internal_ints_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 8, this->_internal_ints(i), target); + } + + // repeated bytes strings = 9; + for (int i = 0, n = this->_internal_strings_size(); i < n; i++) { + const auto &s = this->_internal_strings(i); + target = stream->WriteBytes(9, s, target); + } + + // repeated .onnx.TensorProto tensors = 10; + for (unsigned i = 0, + n = static_cast(this->_internal_tensors_size()); + i < n; i++) { + const auto &repfield = this->_internal_tensors(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 10, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.GraphProto graphs = 11; + for (unsigned i = 0, n = static_cast(this->_internal_graphs_size()); + i < n; i++) { + const auto &repfield = this->_internal_graphs(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 11, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string doc_string = 13; + if (cached_has_bits & 0x00000004u) { + target = + stream->WriteStringMaybeAliased(13, this->_internal_doc_string(), target); + } + + // optional .onnx.TypeProto tp = 14; + if (cached_has_bits & 0x00000040u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 14, _Internal::tp(this), _Internal::tp(this).GetCachedSize(), target, + stream); + } + + // repeated .onnx.TypeProto type_protos = 15; + for (unsigned i = 0, + n = static_cast(this->_internal_type_protos_size()); + i < n; i++) { + const auto &repfield = this->_internal_type_protos(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 15, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .onnx.AttributeProto.AttributeType type = 20; + if (cached_has_bits & 0x00000400u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 20, this->_internal_type(), target); + } + + // optional string ref_attr_name = 21; + if (cached_has_bits & 0x00000008u) { + target = stream->WriteStringMaybeAliased( + 21, this->_internal_ref_attr_name(), target); + } + + // optional .onnx.SparseTensorProto sparse_tensor = 22; + if (cached_has_bits & 0x00000080u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 22, _Internal::sparse_tensor(this), + _Internal::sparse_tensor(this).GetCachedSize(), target, stream); + } + + // repeated .onnx.SparseTensorProto sparse_tensors = 23; + for (unsigned i = 0, n = static_cast( + this->_internal_sparse_tensors_size()); + i < n; i++) { + const auto &repfield = this->_internal_sparse_tensors(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 23, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.AttributeProto) + return target; +} + +size_t AttributeProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.AttributeProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated float floats = 7; + { + unsigned int count = + static_cast(this->_internal_floats_size()); + size_t data_size = 4UL * count; + total_size += 1 * ::_pbi::FromIntSize(this->_internal_floats_size()); + total_size += data_size; + } + + // repeated int64 ints = 8; + { + size_t data_size = ::_pbi::WireFormatLite::Int64Size(this->ints_); + total_size += 1 * ::_pbi::FromIntSize(this->_internal_ints_size()); + total_size += data_size; + } + + // repeated bytes strings = 9; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(strings_.size()); + for (int i = 0, n = strings_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + strings_.Get(i)); + } + + // repeated .onnx.TensorProto tensors = 10; + total_size += 1UL * this->_internal_tensors_size(); + for (const auto &msg : this->tensors_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.GraphProto graphs = 11; + total_size += 1UL * this->_internal_graphs_size(); + for (const auto &msg : this->graphs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.TypeProto type_protos = 15; + total_size += 1UL * this->_internal_type_protos_size(); + for (const auto &msg : this->type_protos_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.SparseTensorProto sparse_tensors = 23; + total_size += 2UL * this->_internal_sparse_tensors_size(); + for (const auto &msg : this->sparse_tensors_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional bytes s = 4; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_s()); + } + + // optional string doc_string = 13; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional string ref_attr_name = 21; + if (cached_has_bits & 0x00000008u) { + total_size += + 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_ref_attr_name()); + } + + // optional .onnx.TensorProto t = 5; + if (cached_has_bits & 0x00000010u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*t_); + } + + // optional .onnx.GraphProto g = 6; + if (cached_has_bits & 0x00000020u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*g_); + } + + // optional .onnx.TypeProto tp = 14; + if (cached_has_bits & 0x00000040u) { + total_size += + 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*tp_); + } + + // optional .onnx.SparseTensorProto sparse_tensor = 22; + if (cached_has_bits & 0x00000080u) { + total_size += + 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *sparse_tensor_); + } + } + if (cached_has_bits & 0x00000700u) { + // optional int64 i = 3; + if (cached_has_bits & 0x00000100u) { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_i()); + } + + // optional float f = 2; + if (cached_has_bits & 0x00000200u) { + total_size += 1 + 4; + } + + // optional .onnx.AttributeProto.AttributeType type = 20; + if (cached_has_bits & 0x00000400u) { + total_size += + 2 + ::_pbi::WireFormatLite::EnumSize(this->_internal_type()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AttributeProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void AttributeProto::MergeFrom(const AttributeProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.AttributeProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t 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_); + type_protos_.MergeFrom(from.type_protos_); + sparse_tensors_.MergeFrom(from.sparse_tensors_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x000000ffu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_s(from._internal_s()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_ref_attr_name(from._internal_ref_attr_name()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_t()->::onnx::TensorProto::MergeFrom(from._internal_t()); + } + if (cached_has_bits & 0x00000020u) { + _internal_mutable_g()->::onnx::GraphProto::MergeFrom(from._internal_g()); + } + if (cached_has_bits & 0x00000040u) { + _internal_mutable_tp()->::onnx::TypeProto::MergeFrom(from._internal_tp()); + } + if (cached_has_bits & 0x00000080u) { + _internal_mutable_sparse_tensor()->::onnx::SparseTensorProto::MergeFrom( + from._internal_sparse_tensor()); + } + } + if (cached_has_bits & 0x00000700u) { + if (cached_has_bits & 0x00000100u) { + i_ = from.i_; + } + if (cached_has_bits & 0x00000200u) { + f_ = from.f_; + } + if (cached_has_bits & 0x00000400u) { + type_ = from.type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AttributeProto::CopyFrom(const AttributeProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.AttributeProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool AttributeProto::IsInitialized() const { return true; } + +void AttributeProto::InternalSwap(AttributeProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + floats_.InternalSwap(&other->floats_); + ints_.InternalSwap(&other->ints_); + strings_.InternalSwap(&other->strings_); + tensors_.InternalSwap(&other->tensors_); + graphs_.InternalSwap(&other->graphs_); + type_protos_.InternalSwap(&other->type_protos_); + sparse_tensors_.InternalSwap(&other->sparse_tensors_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &s_, lhs_arena, &other->s_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &ref_attr_name_, lhs_arena, &other->ref_attr_name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AttributeProto, type_) + + sizeof(AttributeProto::type_) - PROTOBUF_FIELD_OFFSET(AttributeProto, t_)>( + reinterpret_cast(&t_), reinterpret_cast(&other->t_)); +} + +std::string AttributeProto::GetTypeName() const { + return "onnx.AttributeProto"; +} + +// =================================================================== + +class ValueInfoProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static const ::onnx::TypeProto &type(const ValueInfoProto *msg); + static void set_has_type(HasBits *has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +const ::onnx::TypeProto & +ValueInfoProto::_Internal::type(const ValueInfoProto *msg) { + return *msg->type_; +} +ValueInfoProto::ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + metadata_props_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.ValueInfoProto) +} +ValueInfoProto::ValueInfoProto(const ValueInfoProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + if (from._internal_has_type()) { + type_ = new ::onnx::TypeProto(*from.type_); + } else { + type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:onnx.ValueInfoProto) +} + +inline void ValueInfoProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + type_ = nullptr; +} + +ValueInfoProto::~ValueInfoProto() { + // @@protoc_insertion_point(destructor:onnx.ValueInfoProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ValueInfoProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + doc_string_.Destroy(); + if (this != internal_default_instance()) + delete type_; +} + +void ValueInfoProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void ValueInfoProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.ValueInfoProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + GOOGLE_DCHECK(type_ != nullptr); + type_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *ValueInfoProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TypeProto type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string doc_string = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *ValueInfoProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.ValueInfoProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(1, this->_internal_name(), target); + } + + // optional .onnx.TypeProto type = 2; + if (cached_has_bits & 0x00000004u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::type(this), _Internal::type(this).GetCachedSize(), target, + stream); + } + + // optional string doc_string = 3; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteStringMaybeAliased(3, this->_internal_doc_string(), target); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 4; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 4, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.ValueInfoProto) + return target; +} + +size_t ValueInfoProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.ValueInfoProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.StringStringEntryProto metadata_props = 4; + total_size += 1UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string doc_string = 3; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional .onnx.TypeProto type = 2; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*type_); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ValueInfoProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void ValueInfoProto::MergeFrom(const ValueInfoProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.ValueInfoProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000007u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000004u) { + _internal_mutable_type()->::onnx::TypeProto::MergeFrom( + from._internal_type()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ValueInfoProto::CopyFrom(const ValueInfoProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.ValueInfoProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool ValueInfoProto::IsInitialized() const { return true; } + +void ValueInfoProto::InternalSwap(ValueInfoProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + metadata_props_.InternalSwap(&other->metadata_props_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + swap(type_, other->type_); +} + +std::string ValueInfoProto::GetTypeName() const { + return "onnx.ValueInfoProto"; +} + +// =================================================================== + +class NodeProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_op_type(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static void set_has_domain(HasBits *has_bits) { (*has_bits)[0] |= 8u; } + static void set_has_overload(HasBits *has_bits) { (*has_bits)[0] |= 16u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 4u; } +}; + +NodeProto::NodeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + input_(arena), + output_(arena), + attribute_(arena), + metadata_props_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.NodeProto) +} +NodeProto::NodeProto(const NodeProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + input_(from.input_), + output_(from.output_), + attribute_(from.attribute_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + op_type_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + op_type_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_op_type()) { + op_type_.Set(from._internal_op_type(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_domain()) { + domain_.Set(from._internal_domain(), GetArenaForAllocation()); + } + overload_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_overload()) { + overload_.Set(from._internal_overload(), GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:onnx.NodeProto) +} + +inline void NodeProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + op_type_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + op_type_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +NodeProto::~NodeProto() { + // @@protoc_insertion_point(destructor:onnx.NodeProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void NodeProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + op_type_.Destroy(); + doc_string_.Destroy(); + domain_.Destroy(); + overload_.Destroy(); +} + +void NodeProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void NodeProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.NodeProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + input_.Clear(); + output_.Clear(); + attribute_.Clear(); + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + op_type_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + domain_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + overload_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *NodeProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string input = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_input(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string output = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_output(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + // optional string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string op_type = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_op_type(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.AttributeProto attribute = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_attribute(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // optional string doc_string = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string domain = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + auto str = _internal_mutable_domain(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string overload = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_overload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *NodeProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.NodeProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated string input = 1; + for (int i = 0, n = this->_internal_input_size(); i < n; i++) { + const auto &s = this->_internal_input(i); + target = stream->WriteString(1, s, target); + } + + // repeated string output = 2; + for (int i = 0, n = this->_internal_output_size(); i < n; i++) { + const auto &s = this->_internal_output(i); + target = stream->WriteString(2, s, target); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(3, this->_internal_name(), target); + } + + // optional string op_type = 4; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteStringMaybeAliased(4, this->_internal_op_type(), target); + } + + // repeated .onnx.AttributeProto attribute = 5; + for (unsigned i = 0, + n = static_cast(this->_internal_attribute_size()); + i < n; i++) { + const auto &repfield = this->_internal_attribute(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 5, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000004u) { + target = + stream->WriteStringMaybeAliased(6, this->_internal_doc_string(), target); + } + + // optional string domain = 7; + if (cached_has_bits & 0x00000008u) { + target = + stream->WriteStringMaybeAliased(7, this->_internal_domain(), target); + } + + // optional string overload = 8; + if (cached_has_bits & 0x00000010u) { + target = + stream->WriteStringMaybeAliased(8, this->_internal_overload(), target); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 9; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 9, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.NodeProto) + return target; +} + +size_t NodeProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.NodeProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated string input = 1; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size()); + for (int i = 0, n = input_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + input_.Get(i)); + } + + // repeated string output = 2; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size()); + for (int i = 0, n = output_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + output_.Get(i)); + } + + // repeated .onnx.AttributeProto attribute = 5; + total_size += 1UL * this->_internal_attribute_size(); + for (const auto &msg : this->attribute_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 9; + total_size += 1UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + // optional string name = 3; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string op_type = 4; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_op_type()); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional string domain = 7; + if (cached_has_bits & 0x00000008u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_domain()); + } + + // optional string overload = 8; + if (cached_has_bits & 0x00000010u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_overload()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void NodeProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void NodeProto::MergeFrom(const NodeProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.NodeProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + input_.MergeFrom(from.input_); + output_.MergeFrom(from.output_); + attribute_.MergeFrom(from.attribute_); + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_op_type(from._internal_op_type()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_domain(from._internal_domain()); + } + if (cached_has_bits & 0x00000010u) { + _internal_set_overload(from._internal_overload()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void NodeProto::CopyFrom(const NodeProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.NodeProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool NodeProto::IsInitialized() const { return true; } + +void NodeProto::InternalSwap(NodeProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + input_.InternalSwap(&other->input_); + output_.InternalSwap(&other->output_); + attribute_.InternalSwap(&other->attribute_); + metadata_props_.InternalSwap(&other->metadata_props_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &op_type_, lhs_arena, &other->op_type_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &domain_, lhs_arena, &other->domain_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &overload_, lhs_arena, &other->overload_, rhs_arena); +} + +std::string NodeProto::GetTypeName() const { return "onnx.NodeProto"; } + +// =================================================================== + +class TrainingInfoProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::onnx::GraphProto &initialization(const TrainingInfoProto *msg); + static void set_has_initialization(HasBits *has_bits) { + (*has_bits)[0] |= 1u; + } + static const ::onnx::GraphProto &algorithm(const TrainingInfoProto *msg); + static void set_has_algorithm(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +const ::onnx::GraphProto & +TrainingInfoProto::_Internal::initialization(const TrainingInfoProto *msg) { + return *msg->initialization_; +} +const ::onnx::GraphProto & +TrainingInfoProto::_Internal::algorithm(const TrainingInfoProto *msg) { + return *msg->algorithm_; +} +TrainingInfoProto::TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + initialization_binding_(arena), + update_binding_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TrainingInfoProto) +} +TrainingInfoProto::TrainingInfoProto(const TrainingInfoProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + initialization_binding_(from.initialization_binding_), + update_binding_(from.update_binding_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_initialization()) { + initialization_ = new ::onnx::GraphProto(*from.initialization_); + } else { + initialization_ = nullptr; + } + if (from._internal_has_algorithm()) { + algorithm_ = new ::onnx::GraphProto(*from.algorithm_); + } else { + algorithm_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:onnx.TrainingInfoProto) +} + +inline void TrainingInfoProto::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&initialization_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&algorithm_) - + reinterpret_cast(&initialization_)) + + sizeof(algorithm_)); +} + +TrainingInfoProto::~TrainingInfoProto() { + // @@protoc_insertion_point(destructor:onnx.TrainingInfoProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TrainingInfoProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete initialization_; + if (this != internal_default_instance()) + delete algorithm_; +} + +void TrainingInfoProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TrainingInfoProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TrainingInfoProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + initialization_binding_.Clear(); + update_binding_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(initialization_ != nullptr); + initialization_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(algorithm_ != nullptr); + algorithm_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TrainingInfoProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .onnx.GraphProto initialization = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_initialization(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.GraphProto algorithm = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_algorithm(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto initialization_binding = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_initialization_binding(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto update_binding = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_update_binding(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TrainingInfoProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TrainingInfoProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .onnx.GraphProto initialization = 1; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::initialization(this), + _Internal::initialization(this).GetCachedSize(), target, stream); + } + + // optional .onnx.GraphProto algorithm = 2; + if (cached_has_bits & 0x00000002u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::algorithm(this), + _Internal::algorithm(this).GetCachedSize(), target, stream); + } + + // repeated .onnx.StringStringEntryProto initialization_binding = 3; + for (unsigned i = 0, n = static_cast( + this->_internal_initialization_binding_size()); + i < n; i++) { + const auto &repfield = this->_internal_initialization_binding(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 3, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.StringStringEntryProto update_binding = 4; + for (unsigned i = 0, n = static_cast( + this->_internal_update_binding_size()); + i < n; i++) { + const auto &repfield = this->_internal_update_binding(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 4, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TrainingInfoProto) + return target; +} + +size_t TrainingInfoProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TrainingInfoProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.StringStringEntryProto initialization_binding = 3; + total_size += 1UL * this->_internal_initialization_binding_size(); + for (const auto &msg : this->initialization_binding_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto update_binding = 4; + total_size += 1UL * this->_internal_update_binding_size(); + for (const auto &msg : this->update_binding_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .onnx.GraphProto initialization = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *initialization_); + } + + // optional .onnx.GraphProto algorithm = 2; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *algorithm_); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TrainingInfoProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TrainingInfoProto::MergeFrom(const TrainingInfoProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TrainingInfoProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + initialization_binding_.MergeFrom(from.initialization_binding_); + update_binding_.MergeFrom(from.update_binding_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_initialization()->::onnx::GraphProto::MergeFrom( + from._internal_initialization()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_algorithm()->::onnx::GraphProto::MergeFrom( + from._internal_algorithm()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TrainingInfoProto::CopyFrom(const TrainingInfoProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TrainingInfoProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TrainingInfoProto::IsInitialized() const { return true; } + +void TrainingInfoProto::InternalSwap(TrainingInfoProto *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + initialization_binding_.InternalSwap(&other->initialization_binding_); + update_binding_.InternalSwap(&other->update_binding_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TrainingInfoProto, algorithm_) + + sizeof(TrainingInfoProto::algorithm_) - + PROTOBUF_FIELD_OFFSET(TrainingInfoProto, initialization_)>( + reinterpret_cast(&initialization_), + reinterpret_cast(&other->initialization_)); +} + +std::string TrainingInfoProto::GetTypeName() const { + return "onnx.TrainingInfoProto"; +} + +// =================================================================== + +class ModelProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_ir_version(HasBits *has_bits) { (*has_bits)[0] |= 32u; } + static void set_has_producer_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_producer_version(HasBits *has_bits) { + (*has_bits)[0] |= 2u; + } + static void set_has_domain(HasBits *has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_model_version(HasBits *has_bits) { + (*has_bits)[0] |= 64u; + } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 8u; } + static const ::onnx::GraphProto &graph(const ModelProto *msg); + static void set_has_graph(HasBits *has_bits) { (*has_bits)[0] |= 16u; } +}; + +const ::onnx::GraphProto &ModelProto::_Internal::graph(const ModelProto *msg) { + return *msg->graph_; +} +ModelProto::ModelProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + opset_import_(arena), + metadata_props_(arena), + training_info_(arena), + functions_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.ModelProto) +} +ModelProto::ModelProto(const ModelProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + opset_import_(from.opset_import_), + metadata_props_(from.metadata_props_), + training_info_(from.training_info_), + functions_(from.functions_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + producer_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + producer_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_producer_name()) { + producer_name_.Set(from._internal_producer_name(), GetArenaForAllocation()); + } + producer_version_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + producer_version_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_producer_version()) { + producer_version_.Set(from._internal_producer_version(), + GetArenaForAllocation()); + } + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_domain()) { + domain_.Set(from._internal_domain(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + if (from._internal_has_graph()) { + graph_ = new ::onnx::GraphProto(*from.graph_); + } else { + graph_ = nullptr; + } + ::memcpy(&ir_version_, &from.ir_version_, + static_cast(reinterpret_cast(&model_version_) - + reinterpret_cast(&ir_version_)) + + sizeof(model_version_)); + // @@protoc_insertion_point(copy_constructor:onnx.ModelProto) +} + +inline void ModelProto::SharedCtor() { + producer_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + producer_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + producer_version_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + producer_version_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&graph_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&model_version_) - + reinterpret_cast(&graph_)) + + sizeof(model_version_)); +} + +ModelProto::~ModelProto() { + // @@protoc_insertion_point(destructor:onnx.ModelProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void ModelProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + producer_name_.Destroy(); + producer_version_.Destroy(); + domain_.Destroy(); + doc_string_.Destroy(); + if (this != internal_default_instance()) + delete graph_; +} + +void ModelProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void ModelProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.ModelProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + opset_import_.Clear(); + metadata_props_.Clear(); + training_info_.Clear(); + functions_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000001fu) { + if (cached_has_bits & 0x00000001u) { + producer_name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + producer_version_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + domain_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000010u) { + GOOGLE_DCHECK(graph_ != nullptr); + graph_->Clear(); + } + } + if (cached_has_bits & 0x00000060u) { + ::memset(&ir_version_, 0, + static_cast(reinterpret_cast(&model_version_) - + reinterpret_cast(&ir_version_)) + + sizeof(model_version_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *ModelProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 ir_version = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_ir_version(&has_bits); + ir_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string producer_name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_producer_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string producer_version = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_producer_version(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string domain = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + auto str = _internal_mutable_domain(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 model_version = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _Internal::set_has_model_version(&has_bits); + model_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string doc_string = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.GraphProto graph = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_graph(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.OperatorSetIdProto opset_import = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.TrainingInfoProto training_info = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_training_info(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.FunctionProto functions = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_functions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<202>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *ModelProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.ModelProto) + uint32_t 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 = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 1, this->_internal_ir_version(), target); + } + + // optional string producer_name = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(2, this->_internal_producer_name(), + target); + } + + // optional string producer_version = 3; + if (cached_has_bits & 0x00000002u) { + target = stream->WriteStringMaybeAliased( + 3, this->_internal_producer_version(), target); + } + + // optional string domain = 4; + if (cached_has_bits & 0x00000004u) { + target = + stream->WriteStringMaybeAliased(4, this->_internal_domain(), target); + } + + // optional int64 model_version = 5; + if (cached_has_bits & 0x00000040u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 5, this->_internal_model_version(), target); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000008u) { + target = + stream->WriteStringMaybeAliased(6, this->_internal_doc_string(), target); + } + + // optional .onnx.GraphProto graph = 7; + if (cached_has_bits & 0x00000010u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 7, _Internal::graph(this), _Internal::graph(this).GetCachedSize(), + target, stream); + } + + // repeated .onnx.OperatorSetIdProto opset_import = 8; + for (unsigned i = 0, + n = static_cast(this->_internal_opset_import_size()); + i < n; i++) { + const auto &repfield = this->_internal_opset_import(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 8, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 14, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.TrainingInfoProto training_info = 20; + for (unsigned i = 0, + n = static_cast(this->_internal_training_info_size()); + i < n; i++) { + const auto &repfield = this->_internal_training_info(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 20, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.FunctionProto functions = 25; + for (unsigned i = 0, + n = static_cast(this->_internal_functions_size()); + i < n; i++) { + const auto &repfield = this->_internal_functions(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 25, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.ModelProto) + return target; +} + +size_t ModelProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.ModelProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.OperatorSetIdProto opset_import = 8; + total_size += 1UL * this->_internal_opset_import_size(); + for (const auto &msg : this->opset_import_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + total_size += 1UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.TrainingInfoProto training_info = 20; + total_size += 2UL * this->_internal_training_info_size(); + for (const auto &msg : this->training_info_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.FunctionProto functions = 25; + total_size += 2UL * this->_internal_functions_size(); + for (const auto &msg : this->functions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + // optional string producer_name = 2; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_producer_name()); + } + + // optional string producer_version = 3; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_producer_version()); + } + + // optional string domain = 4; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_domain()); + } + + // optional string doc_string = 6; + if (cached_has_bits & 0x00000008u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional .onnx.GraphProto graph = 7; + if (cached_has_bits & 0x00000010u) { + total_size += + 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*graph_); + } + + // optional int64 ir_version = 1; + if (cached_has_bits & 0x00000020u) { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ir_version()); + } + + // optional int64 model_version = 5; + if (cached_has_bits & 0x00000040u) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this->_internal_model_version()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ModelProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void ModelProto::MergeFrom(const ModelProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.ModelProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + opset_import_.MergeFrom(from.opset_import_); + metadata_props_.MergeFrom(from.metadata_props_); + training_info_.MergeFrom(from.training_info_); + functions_.MergeFrom(from.functions_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000007fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_producer_name(from._internal_producer_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_producer_version(from._internal_producer_version()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_domain(from._internal_domain()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000010u) { + _internal_mutable_graph()->::onnx::GraphProto::MergeFrom( + from._internal_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; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ModelProto::CopyFrom(const ModelProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.ModelProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool ModelProto::IsInitialized() const { return true; } + +void ModelProto::InternalSwap(ModelProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + opset_import_.InternalSwap(&other->opset_import_); + metadata_props_.InternalSwap(&other->metadata_props_); + training_info_.InternalSwap(&other->training_info_); + functions_.InternalSwap(&other->functions_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &producer_name_, lhs_arena, &other->producer_name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &producer_version_, lhs_arena, &other->producer_version_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &domain_, lhs_arena, &other->domain_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ModelProto, model_version_) + + sizeof(ModelProto::model_version_) - + PROTOBUF_FIELD_OFFSET(ModelProto, graph_)>( + reinterpret_cast(&graph_), + reinterpret_cast(&other->graph_)); +} + +std::string ModelProto::GetTypeName() const { return "onnx.ModelProto"; } + +// =================================================================== + +class StringStringEntryProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_key(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_value(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +StringStringEntryProto::StringStringEntryProto( + ::PROTOBUF_NAMESPACE_ID::Arena *arena, bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.StringStringEntryProto) +} +StringStringEntryProto::StringStringEntryProto( + const StringStringEntryProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + key_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + key_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_key()) { + key_.Set(from._internal_key(), GetArenaForAllocation()); + } + value_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_value()) { + value_.Set(from._internal_value(), GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:onnx.StringStringEntryProto) +} + +inline void StringStringEntryProto::SharedCtor() { + key_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + key_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +StringStringEntryProto::~StringStringEntryProto() { + // @@protoc_insertion_point(destructor:onnx.StringStringEntryProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void StringStringEntryProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + key_.Destroy(); + value_.Destroy(); +} + +void StringStringEntryProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void StringStringEntryProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.StringStringEntryProto) + uint32_t 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 & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + key_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + value_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *StringStringEntryProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *StringStringEntryProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.StringStringEntryProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string key = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(1, this->_internal_key(), target); + } + + // optional string value = 2; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteStringMaybeAliased(2, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.StringStringEntryProto) + return target; +} + +size_t StringStringEntryProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.StringStringEntryProto) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional string key = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_key()); + } + + // optional string value = 2; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_value()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void StringStringEntryProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void StringStringEntryProto::MergeFrom(const StringStringEntryProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.StringStringEntryProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_key(from._internal_key()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_value(from._internal_value()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void StringStringEntryProto::CopyFrom(const StringStringEntryProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.StringStringEntryProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool StringStringEntryProto::IsInitialized() const { return true; } + +void StringStringEntryProto::InternalSwap(StringStringEntryProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &key_, lhs_arena, &other->key_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &value_, lhs_arena, &other->value_, rhs_arena); +} + +std::string StringStringEntryProto::GetTypeName() const { + return "onnx.StringStringEntryProto"; +} + +// =================================================================== + +class TensorAnnotation::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_tensor_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +TensorAnnotation::TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + quant_parameter_tensor_names_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TensorAnnotation) +} +TensorAnnotation::TensorAnnotation(const TensorAnnotation &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + quant_parameter_tensor_names_(from.quant_parameter_tensor_names_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + tensor_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + tensor_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_tensor_name()) { + tensor_name_.Set(from._internal_tensor_name(), GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:onnx.TensorAnnotation) +} + +inline void TensorAnnotation::SharedCtor() { + tensor_name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + tensor_name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +TensorAnnotation::~TensorAnnotation() { + // @@protoc_insertion_point(destructor:onnx.TensorAnnotation) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TensorAnnotation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + tensor_name_.Destroy(); +} + +void TensorAnnotation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TensorAnnotation::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TensorAnnotation) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + quant_parameter_tensor_names_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + tensor_name_.ClearNonDefaultToEmpty(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TensorAnnotation::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string tensor_name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_tensor_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_quant_parameter_tensor_names(), + ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TensorAnnotation::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorAnnotation) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string tensor_name = 1; + if (cached_has_bits & 0x00000001u) { + target = + stream->WriteStringMaybeAliased(1, this->_internal_tensor_name(), target); + } + + // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2; + for (unsigned i = 0, n = static_cast( + this->_internal_quant_parameter_tensor_names_size()); + i < n; i++) { + const auto &repfield = this->_internal_quant_parameter_tensor_names(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorAnnotation) + return target; +} + +size_t TensorAnnotation::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TensorAnnotation) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2; + total_size += 1UL * this->_internal_quant_parameter_tensor_names_size(); + for (const auto &msg : this->quant_parameter_tensor_names_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // optional string tensor_name = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_tensor_name()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TensorAnnotation::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TensorAnnotation::MergeFrom(const TensorAnnotation &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorAnnotation) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + quant_parameter_tensor_names_.MergeFrom(from.quant_parameter_tensor_names_); + if (from._internal_has_tensor_name()) { + _internal_set_tensor_name(from._internal_tensor_name()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TensorAnnotation::CopyFrom(const TensorAnnotation &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorAnnotation) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TensorAnnotation::IsInitialized() const { return true; } + +void TensorAnnotation::InternalSwap(TensorAnnotation *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + quant_parameter_tensor_names_.InternalSwap( + &other->quant_parameter_tensor_names_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &tensor_name_, lhs_arena, &other->tensor_name_, rhs_arena); +} + +std::string TensorAnnotation::GetTypeName() const { + return "onnx.TensorAnnotation"; +} + +// =================================================================== + +class GraphProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +GraphProto::GraphProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + node_(arena), + initializer_(arena), + input_(arena), + output_(arena), + value_info_(arena), + quantization_annotation_(arena), + sparse_initializer_(arena), + metadata_props_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.GraphProto) +} +GraphProto::GraphProto(const GraphProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + node_(from.node_), + initializer_(from.initializer_), + input_(from.input_), + output_(from.output_), + value_info_(from.value_info_), + quantization_annotation_(from.quantization_annotation_), + sparse_initializer_(from.sparse_initializer_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:onnx.GraphProto) +} + +inline void GraphProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +GraphProto::~GraphProto() { + // @@protoc_insertion_point(destructor:onnx.GraphProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void GraphProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + doc_string_.Destroy(); +} + +void GraphProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void GraphProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.GraphProto) + uint32_t 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(); + quantization_annotation_.Clear(); + sparse_initializer_.Clear(); + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + doc_string_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *GraphProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .onnx.NodeProto node = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_node(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + // optional string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.TensorProto initializer = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_initializer(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // optional string doc_string = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.ValueInfoProto input = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_input(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.ValueInfoProto output = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_output(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.ValueInfoProto value_info = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_value_info(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.TensorAnnotation quantization_annotation = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_quantization_annotation(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.SparseTensorProto sparse_initializer = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sparse_initializer(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *GraphProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.GraphProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .onnx.NodeProto node = 1; + for (unsigned i = 0, n = static_cast(this->_internal_node_size()); + i < n; i++) { + const auto &repfield = this->_internal_node(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, repfield, repfield.GetCachedSize(), target, stream); + } + + cached_has_bits = _has_bits_[0]; + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(2, this->_internal_name(), target); + } + + // repeated .onnx.TensorProto initializer = 5; + for (unsigned i = 0, + n = static_cast(this->_internal_initializer_size()); + i < n; i++) { + const auto &repfield = this->_internal_initializer(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 5, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string doc_string = 10; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteStringMaybeAliased(10, this->_internal_doc_string(), target); + } + + // repeated .onnx.ValueInfoProto input = 11; + for (unsigned i = 0, n = static_cast(this->_internal_input_size()); + i < n; i++) { + const auto &repfield = this->_internal_input(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 11, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.ValueInfoProto output = 12; + for (unsigned i = 0, n = static_cast(this->_internal_output_size()); + i < n; i++) { + const auto &repfield = this->_internal_output(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 12, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.ValueInfoProto value_info = 13; + for (unsigned i = 0, + n = static_cast(this->_internal_value_info_size()); + i < n; i++) { + const auto &repfield = this->_internal_value_info(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 13, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.TensorAnnotation quantization_annotation = 14; + for (unsigned i = 0, n = static_cast( + this->_internal_quantization_annotation_size()); + i < n; i++) { + const auto &repfield = this->_internal_quantization_annotation(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 14, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.SparseTensorProto sparse_initializer = 15; + for (unsigned i = 0, n = static_cast( + this->_internal_sparse_initializer_size()); + i < n; i++) { + const auto &repfield = this->_internal_sparse_initializer(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 15, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 16, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.GraphProto) + return target; +} + +size_t GraphProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.GraphProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.NodeProto node = 1; + total_size += 1UL * this->_internal_node_size(); + for (const auto &msg : this->node_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.TensorProto initializer = 5; + total_size += 1UL * this->_internal_initializer_size(); + for (const auto &msg : this->initializer_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.ValueInfoProto input = 11; + total_size += 1UL * this->_internal_input_size(); + for (const auto &msg : this->input_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.ValueInfoProto output = 12; + total_size += 1UL * this->_internal_output_size(); + for (const auto &msg : this->output_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.ValueInfoProto value_info = 13; + total_size += 1UL * this->_internal_value_info_size(); + for (const auto &msg : this->value_info_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.TensorAnnotation quantization_annotation = 14; + total_size += 1UL * this->_internal_quantization_annotation_size(); + for (const auto &msg : this->quantization_annotation_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.SparseTensorProto sparse_initializer = 15; + total_size += 1UL * this->_internal_sparse_initializer_size(); + for (const auto &msg : this->sparse_initializer_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + total_size += 2UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional string name = 2; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string doc_string = 10; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void GraphProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void GraphProto::MergeFrom(const GraphProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.GraphProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t 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_); + quantization_annotation_.MergeFrom(from.quantization_annotation_); + sparse_initializer_.MergeFrom(from.sparse_initializer_); + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_doc_string(from._internal_doc_string()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void GraphProto::CopyFrom(const GraphProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.GraphProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool GraphProto::IsInitialized() const { return true; } + +void GraphProto::InternalSwap(GraphProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + node_.InternalSwap(&other->node_); + initializer_.InternalSwap(&other->initializer_); + input_.InternalSwap(&other->input_); + output_.InternalSwap(&other->output_); + value_info_.InternalSwap(&other->value_info_); + quantization_annotation_.InternalSwap(&other->quantization_annotation_); + sparse_initializer_.InternalSwap(&other->sparse_initializer_); + metadata_props_.InternalSwap(&other->metadata_props_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); +} + +std::string GraphProto::GetTypeName() const { return "onnx.GraphProto"; } + +// =================================================================== + +class TensorProto_Segment::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_begin(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_end(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +TensorProto_Segment::TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TensorProto.Segment) +} +TensorProto_Segment::TensorProto_Segment(const TensorProto_Segment &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _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:onnx.TensorProto.Segment) +} + +inline void TensorProto_Segment::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&begin_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&begin_)) + + sizeof(end_)); +} + +TensorProto_Segment::~TensorProto_Segment() { + // @@protoc_insertion_point(destructor:onnx.TensorProto.Segment) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TensorProto_Segment::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void TensorProto_Segment::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TensorProto_Segment::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TensorProto.Segment) + uint32_t 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 & 0x00000003u) { + ::memset(&begin_, 0, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&begin_)) + + sizeof(end_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TensorProto_Segment::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int64 begin = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_begin(&has_bits); + begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 end = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_end(&has_bits); + end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TensorProto_Segment::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto.Segment) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int64 begin = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 1, this->_internal_begin(), target); + } + + // optional int64 end = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_end(), + target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto.Segment) + return target; +} + +size_t TensorProto_Segment::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto.Segment) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional int64 begin = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_begin()); + } + + // optional int64 end = 2; + if (cached_has_bits & 0x00000002u) { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_end()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TensorProto_Segment::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TensorProto_Segment::MergeFrom(const TensorProto_Segment &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto.Segment) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + begin_ = from.begin_; + } + if (cached_has_bits & 0x00000002u) { + end_ = from.end_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TensorProto_Segment::CopyFrom(const TensorProto_Segment &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto.Segment) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TensorProto_Segment::IsInitialized() const { return true; } + +void TensorProto_Segment::InternalSwap(TensorProto_Segment *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TensorProto_Segment, end_) + + sizeof(TensorProto_Segment::end_) - + PROTOBUF_FIELD_OFFSET(TensorProto_Segment, begin_)>( + reinterpret_cast(&begin_), + reinterpret_cast(&other->begin_)); +} + +std::string TensorProto_Segment::GetTypeName() const { + return "onnx.TensorProto.Segment"; +} + +// =================================================================== + +class TensorProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_data_type(HasBits *has_bits) { (*has_bits)[0] |= 16u; } + static const ::onnx::TensorProto_Segment &segment(const TensorProto *msg); + static void set_has_segment(HasBits *has_bits) { (*has_bits)[0] |= 8u; } + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_raw_data(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static void set_has_data_location(HasBits *has_bits) { + (*has_bits)[0] |= 32u; + } +}; + +const ::onnx::TensorProto_Segment & +TensorProto::_Internal::segment(const TensorProto *msg) { + return *msg->segment_; +} +TensorProto::TensorProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + dims_(arena), + float_data_(arena), + int32_data_(arena), + string_data_(arena), + int64_data_(arena), + double_data_(arena), + uint64_data_(arena), + external_data_(arena), + metadata_props_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TensorProto) +} +TensorProto::TensorProto(const TensorProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + 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_), + external_data_(from.external_data_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + raw_data_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + raw_data_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_raw_data()) { + raw_data_.Set(from._internal_raw_data(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + if (from._internal_has_segment()) { + segment_ = new ::onnx::TensorProto_Segment(*from.segment_); + } else { + segment_ = nullptr; + } + ::memcpy(&data_type_, &from.data_type_, + static_cast(reinterpret_cast(&data_location_) - + reinterpret_cast(&data_type_)) + + sizeof(data_location_)); + // @@protoc_insertion_point(copy_constructor:onnx.TensorProto) +} + +inline void TensorProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + raw_data_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + raw_data_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&segment_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&data_location_) - + reinterpret_cast(&segment_)) + + sizeof(data_location_)); +} + +TensorProto::~TensorProto() { + // @@protoc_insertion_point(destructor:onnx.TensorProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TensorProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + raw_data_.Destroy(); + doc_string_.Destroy(); + if (this != internal_default_instance()) + delete segment_; +} + +void TensorProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void TensorProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TensorProto) + uint32_t 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(); + external_data_.Clear(); + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + raw_data_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + GOOGLE_DCHECK(segment_ != nullptr); + segment_->Clear(); + } + } + if (cached_has_bits & 0x00000030u) { + ::memset(&data_type_, 0, + static_cast(reinterpret_cast(&data_location_) - + reinterpret_cast(&data_type_)) + + sizeof(data_location_)); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TensorProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int64 dims = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_dims( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr)); + } else if (static_cast(tag) == 10) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser( + _internal_mutable_dims(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int32 data_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_data_type(&has_bits); + data_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorProto.Segment segment = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_segment(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated float float_data = 4 [packed = true]; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser( + _internal_mutable_float_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 37) { + _internal_add_float_data( + ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else + goto handle_unusual; + continue; + // repeated int32 int32_data = 5 [packed = true]; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser( + _internal_mutable_int32_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 40) { + _internal_add_int32_data( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated bytes string_data = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_string_data(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // repeated int64 int64_data = 7 [packed = true]; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser( + _internal_mutable_int64_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 56) { + _internal_add_int64_data( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string name = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional bytes raw_data = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + auto str = _internal_mutable_raw_data(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated double double_data = 10 [packed = true]; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser( + _internal_mutable_double_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 81) { + _internal_add_double_data( + ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else + goto handle_unusual; + continue; + // repeated uint64 uint64_data = 11 [packed = true]; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt64Parser( + _internal_mutable_uint64_data(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 88) { + _internal_add_uint64_data( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string doc_string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto external_data = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_external_data(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<106>(ptr)); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorProto.DataLocation data_location = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE( + ::onnx::TensorProto_DataLocation_IsValid(val))) { + _internal_set_data_location( + static_cast<::onnx::TensorProto_DataLocation>(val)); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint( + 14, val, mutable_unknown_fields()); + } + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { + ptr -= 2; + do { + ptr += 2; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<130>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TensorProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated int64 dims = 1; + for (int i = 0, n = this->_internal_dims_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 1, this->_internal_dims(i), target); + } + + cached_has_bits = _has_bits_[0]; + // optional int32 data_type = 2; + if (cached_has_bits & 0x00000010u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 2, this->_internal_data_type(), target); + } + + // optional .onnx.TensorProto.Segment segment = 3; + if (cached_has_bits & 0x00000008u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 3, _Internal::segment(this), _Internal::segment(this).GetCachedSize(), + target, stream); + } + + // repeated float float_data = 4 [packed = true]; + if (this->_internal_float_data_size() > 0) { + target = stream->WriteFixedPacked(4, _internal_float_data(), target); + } + + // repeated int32 int32_data = 5 [packed = true]; + { + int byte_size = + _int32_data_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = + stream->WriteInt32Packed(5, _internal_int32_data(), byte_size, target); + } + } + + // repeated bytes string_data = 6; + for (int i = 0, n = this->_internal_string_data_size(); i < n; i++) { + const auto &s = this->_internal_string_data(i); + target = stream->WriteBytes(6, s, target); + } + + // repeated int64 int64_data = 7 [packed = true]; + { + int byte_size = + _int64_data_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = + stream->WriteInt64Packed(7, _internal_int64_data(), byte_size, target); + } + } + + // optional string name = 8; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(8, this->_internal_name(), target); + } + + // optional bytes raw_data = 9; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteBytesMaybeAliased(9, this->_internal_raw_data(), target); + } + + // repeated double double_data = 10 [packed = true]; + if (this->_internal_double_data_size() > 0) { + target = stream->WriteFixedPacked(10, _internal_double_data(), target); + } + + // repeated uint64 uint64_data = 11 [packed = true]; + { + int byte_size = + _uint64_data_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteUInt64Packed(11, _internal_uint64_data(), byte_size, + target); + } + } + + // optional string doc_string = 12; + if (cached_has_bits & 0x00000004u) { + target = + stream->WriteStringMaybeAliased(12, this->_internal_doc_string(), target); + } + + // repeated .onnx.StringStringEntryProto external_data = 13; + for (unsigned i = 0, + n = static_cast(this->_internal_external_data_size()); + i < n; i++) { + const auto &repfield = this->_internal_external_data(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 13, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional .onnx.TensorProto.DataLocation data_location = 14; + if (cached_has_bits & 0x00000020u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 14, this->_internal_data_location(), target); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 16, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorProto) + return target; +} + +size_t TensorProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TensorProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated int64 dims = 1; + { + size_t data_size = ::_pbi::WireFormatLite::Int64Size(this->dims_); + total_size += 1 * ::_pbi::FromIntSize(this->_internal_dims_size()); + total_size += data_size; + } + + // repeated float float_data = 4 [packed = true]; + { + unsigned int count = + static_cast(this->_internal_float_data_size()); + size_t data_size = 4UL * count; + if (data_size > 0) { + total_size += + 1 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + total_size += data_size; + } + + // repeated int32 int32_data = 5 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite::Int32Size(this->int32_data_); + if (data_size > 0) { + total_size += + 1 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _int32_data_cached_byte_size_.store(cached_size, std::memory_order_relaxed); + total_size += data_size; + } + + // repeated bytes string_data = 6; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(string_data_.size()); + for (int i = 0, n = string_data_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + string_data_.Get(i)); + } + + // repeated int64 int64_data = 7 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite::Int64Size(this->int64_data_); + if (data_size > 0) { + total_size += + 1 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _int64_data_cached_byte_size_.store(cached_size, std::memory_order_relaxed); + total_size += data_size; + } + + // repeated double double_data = 10 [packed = true]; + { + unsigned int count = + static_cast(this->_internal_double_data_size()); + size_t data_size = 8UL * count; + if (data_size > 0) { + total_size += + 1 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + total_size += data_size; + } + + // repeated uint64 uint64_data = 11 [packed = true]; + { + size_t data_size = ::_pbi::WireFormatLite::UInt64Size(this->uint64_data_); + if (data_size > 0) { + total_size += + 1 + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _uint64_data_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated .onnx.StringStringEntryProto external_data = 13; + total_size += 1UL * this->_internal_external_data_size(); + for (const auto &msg : this->external_data_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + total_size += 2UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + // optional string name = 8; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional bytes raw_data = 9; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_raw_data()); + } + + // optional string doc_string = 12; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional .onnx.TensorProto.Segment segment = 3; + if (cached_has_bits & 0x00000008u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *segment_); + } + + // optional int32 data_type = 2; + if (cached_has_bits & 0x00000010u) { + total_size += + ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_data_type()); + } + + // optional .onnx.TensorProto.DataLocation data_location = 14; + if (cached_has_bits & 0x00000020u) { + total_size += + 1 + ::_pbi::WireFormatLite::EnumSize(this->_internal_data_location()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TensorProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TensorProto::MergeFrom(const TensorProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t 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_); + external_data_.MergeFrom(from.external_data_); + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000003fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_raw_data(from._internal_raw_data()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000008u) { + _internal_mutable_segment()->::onnx::TensorProto_Segment::MergeFrom( + from._internal_segment()); + } + if (cached_has_bits & 0x00000010u) { + data_type_ = from.data_type_; + } + if (cached_has_bits & 0x00000020u) { + data_location_ = from.data_location_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TensorProto::CopyFrom(const TensorProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TensorProto::IsInitialized() const { return true; } + +void TensorProto::InternalSwap(TensorProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + 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_); + external_data_.InternalSwap(&other->external_data_); + metadata_props_.InternalSwap(&other->metadata_props_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &raw_data_, lhs_arena, &other->raw_data_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TensorProto, data_location_) + + sizeof(TensorProto::data_location_) - + PROTOBUF_FIELD_OFFSET(TensorProto, segment_)>( + reinterpret_cast(&segment_), + reinterpret_cast(&other->segment_)); +} + +std::string TensorProto::GetTypeName() const { return "onnx.TensorProto"; } + +// =================================================================== + +class SparseTensorProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::onnx::TensorProto &values(const SparseTensorProto *msg); + static void set_has_values(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static const ::onnx::TensorProto &indices(const SparseTensorProto *msg); + static void set_has_indices(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +const ::onnx::TensorProto & +SparseTensorProto::_Internal::values(const SparseTensorProto *msg) { + return *msg->values_; +} +const ::onnx::TensorProto & +SparseTensorProto::_Internal::indices(const SparseTensorProto *msg) { + return *msg->indices_; +} +SparseTensorProto::SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), dims_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.SparseTensorProto) +} +SparseTensorProto::SparseTensorProto(const SparseTensorProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + dims_(from.dims_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_values()) { + values_ = new ::onnx::TensorProto(*from.values_); + } else { + values_ = nullptr; + } + if (from._internal_has_indices()) { + indices_ = new ::onnx::TensorProto(*from.indices_); + } else { + indices_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:onnx.SparseTensorProto) +} + +inline void SparseTensorProto::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&values_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&indices_) - + reinterpret_cast(&values_)) + + sizeof(indices_)); +} + +SparseTensorProto::~SparseTensorProto() { + // @@protoc_insertion_point(destructor:onnx.SparseTensorProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void SparseTensorProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete values_; + if (this != internal_default_instance()) + delete indices_; +} + +void SparseTensorProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SparseTensorProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.SparseTensorProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + dims_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + GOOGLE_DCHECK(values_ != nullptr); + values_->Clear(); + } + if (cached_has_bits & 0x00000002u) { + GOOGLE_DCHECK(indices_ != nullptr); + indices_->Clear(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *SparseTensorProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .onnx.TensorProto values = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_values(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorProto indices = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_indices(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int64 dims = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + ptr -= 1; + do { + ptr += 1; + _internal_add_dims( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr)); + } else if (static_cast(tag) == 26) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser( + _internal_mutable_dims(), ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *SparseTensorProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.SparseTensorProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .onnx.TensorProto values = 1; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::values(this), _Internal::values(this).GetCachedSize(), + target, stream); + } + + // optional .onnx.TensorProto indices = 2; + if (cached_has_bits & 0x00000002u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::indices(this), _Internal::indices(this).GetCachedSize(), + target, stream); + } + + // repeated int64 dims = 3; + for (int i = 0, n = this->_internal_dims_size(); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 3, this->_internal_dims(i), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.SparseTensorProto) + return target; +} + +size_t SparseTensorProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.SparseTensorProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated int64 dims = 3; + { + size_t data_size = ::_pbi::WireFormatLite::Int64Size(this->dims_); + total_size += 1 * ::_pbi::FromIntSize(this->_internal_dims_size()); + total_size += data_size; + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + // optional .onnx.TensorProto values = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *values_); + } + + // optional .onnx.TensorProto indices = 2; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *indices_); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SparseTensorProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void SparseTensorProto::MergeFrom(const SparseTensorProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.SparseTensorProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + dims_.MergeFrom(from.dims_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_values()->::onnx::TensorProto::MergeFrom( + from._internal_values()); + } + if (cached_has_bits & 0x00000002u) { + _internal_mutable_indices()->::onnx::TensorProto::MergeFrom( + from._internal_indices()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SparseTensorProto::CopyFrom(const SparseTensorProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.SparseTensorProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool SparseTensorProto::IsInitialized() const { return true; } + +void SparseTensorProto::InternalSwap(SparseTensorProto *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + dims_.InternalSwap(&other->dims_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SparseTensorProto, indices_) + + sizeof(SparseTensorProto::indices_) - + PROTOBUF_FIELD_OFFSET(SparseTensorProto, values_)>( + reinterpret_cast(&values_), + reinterpret_cast(&other->values_)); +} + +std::string SparseTensorProto::GetTypeName() const { + return "onnx.SparseTensorProto"; +} + +// =================================================================== + +class TensorShapeProto_Dimension::_Internal { +public: + using HasBits = + decltype(std::declval()._has_bits_); + static void set_has_denotation(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +TensorShapeProto_Dimension::TensorShapeProto_Dimension( + ::PROTOBUF_NAMESPACE_ID::Arena *arena, bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto.Dimension) +} +TensorShapeProto_Dimension::TensorShapeProto_Dimension( + const TensorShapeProto_Dimension &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + denotation_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + denotation_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_denotation()) { + denotation_.Set(from._internal_denotation(), GetArenaForAllocation()); + } + clear_has_value(); + switch (from.value_case()) { + case kDimValue: { + _internal_set_dim_value(from._internal_dim_value()); + break; + } + case kDimParam: { + _internal_set_dim_param(from._internal_dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto.Dimension) +} + +inline void TensorShapeProto_Dimension::SharedCtor() { + denotation_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + denotation_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_value(); +} + +TensorShapeProto_Dimension::~TensorShapeProto_Dimension() { + // @@protoc_insertion_point(destructor:onnx.TensorShapeProto.Dimension) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TensorShapeProto_Dimension::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + denotation_.Destroy(); + if (has_value()) { + clear_value(); + } +} + +void TensorShapeProto_Dimension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TensorShapeProto_Dimension::clear_value() { + // @@protoc_insertion_point(one_of_clear_start:onnx.TensorShapeProto.Dimension) + switch (value_case()) { + case kDimValue: { + // No need to clear + break; + } + case kDimParam: { + value_.dim_param_.Destroy(); + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + +void TensorShapeProto_Dimension::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto.Dimension) + uint32_t 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) { + denotation_.ClearNonDefaultToEmpty(); + } + clear_value(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char * +TensorShapeProto_Dimension::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 dim_value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _internal_set_dim_value( + ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // string dim_param = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + auto str = _internal_mutable_dim_param(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string denotation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + auto str = _internal_mutable_denotation(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TensorShapeProto_Dimension::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto.Dimension) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (value_case()) { + case kDimValue: { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 1, this->_internal_dim_value(), target); + break; + } + case kDimParam: { + target = + stream->WriteStringMaybeAliased(2, this->_internal_dim_param(), target); + break; + } + default:; + } + cached_has_bits = _has_bits_[0]; + // optional string denotation = 3; + if (cached_has_bits & 0x00000001u) { + target = + stream->WriteStringMaybeAliased(3, this->_internal_denotation(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto.Dimension) + return target; +} + +size_t TensorShapeProto_Dimension::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto.Dimension) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // optional string denotation = 3; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_denotation()); + } + + switch (value_case()) { + // int64 dim_value = 1; + case kDimValue: { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_dim_value()); + break; + } + // string dim_param = 2; + case kDimParam: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TensorShapeProto_Dimension::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TensorShapeProto_Dimension::MergeFrom( + const TensorShapeProto_Dimension &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto.Dimension) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_has_denotation()) { + _internal_set_denotation(from._internal_denotation()); + } + switch (from.value_case()) { + case kDimValue: { + _internal_set_dim_value(from._internal_dim_value()); + break; + } + case kDimParam: { + _internal_set_dim_param(from._internal_dim_param()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TensorShapeProto_Dimension::CopyFrom( + const TensorShapeProto_Dimension &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto.Dimension) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TensorShapeProto_Dimension::IsInitialized() const { return true; } + +void TensorShapeProto_Dimension::InternalSwap( + TensorShapeProto_Dimension *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &denotation_, lhs_arena, &other->denotation_, rhs_arena); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +std::string TensorShapeProto_Dimension::GetTypeName() const { + return "onnx.TensorShapeProto.Dimension"; +} + +// =================================================================== + +class TensorShapeProto::_Internal { +public: +}; + +TensorShapeProto::TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), dim_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TensorShapeProto) +} +TensorShapeProto::TensorShapeProto(const TensorShapeProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), dim_(from.dim_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:onnx.TensorShapeProto) +} + +inline void TensorShapeProto::SharedCtor() {} + +TensorShapeProto::~TensorShapeProto() { + // @@protoc_insertion_point(destructor:onnx.TensorShapeProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TensorShapeProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); +} + +void TensorShapeProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TensorShapeProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TensorShapeProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + dim_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TensorShapeProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .onnx.TensorShapeProto.Dimension dim = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_dim(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TensorShapeProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TensorShapeProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // repeated .onnx.TensorShapeProto.Dimension dim = 1; + for (unsigned i = 0, n = static_cast(this->_internal_dim_size()); + i < n; i++) { + const auto &repfield = this->_internal_dim(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TensorShapeProto) + return target; +} + +size_t TensorShapeProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TensorShapeProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated .onnx.TensorShapeProto.Dimension dim = 1; + total_size += 1UL * this->_internal_dim_size(); + for (const auto &msg : this->dim_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TensorShapeProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TensorShapeProto::MergeFrom(const TensorShapeProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TensorShapeProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + dim_.MergeFrom(from.dim_); + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TensorShapeProto::CopyFrom(const TensorShapeProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TensorShapeProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TensorShapeProto::IsInitialized() const { return true; } + +void TensorShapeProto::InternalSwap(TensorShapeProto *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + dim_.InternalSwap(&other->dim_); +} + +std::string TensorShapeProto::GetTypeName() const { + return "onnx.TensorShapeProto"; +} + +// =================================================================== + +class TypeProto_Tensor::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_elem_type(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static const ::onnx::TensorShapeProto &shape(const TypeProto_Tensor *msg); + static void set_has_shape(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TensorShapeProto & +TypeProto_Tensor::_Internal::shape(const TypeProto_Tensor *msg) { + return *msg->shape_; +} +TypeProto_Tensor::TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Tensor) +} +TypeProto_Tensor::TypeProto_Tensor(const TypeProto_Tensor &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_shape()) { + shape_ = new ::onnx::TensorShapeProto(*from.shape_); + } else { + shape_ = nullptr; + } + elem_type_ = from.elem_type_; + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Tensor) +} + +inline void TypeProto_Tensor::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&shape_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&elem_type_) - + reinterpret_cast(&shape_)) + + sizeof(elem_type_)); +} + +TypeProto_Tensor::~TypeProto_Tensor() { + // @@protoc_insertion_point(destructor:onnx.TypeProto.Tensor) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto_Tensor::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete shape_; +} + +void TypeProto_Tensor::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TypeProto_Tensor::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Tensor) + uint32_t 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_ != nullptr); + shape_->Clear(); + } + elem_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto_Tensor::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 elem_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_elem_type(&has_bits); + elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorShapeProto shape = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto_Tensor::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Tensor) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 elem_type = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_elem_type(), target); + } + + // optional .onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::shape(this), _Internal::shape(this).GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Tensor) + return target; +} + +size_t TypeProto_Tensor::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Tensor) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional .onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*shape_); + } + + // optional int32 elem_type = 1; + if (cached_has_bits & 0x00000002u) { + total_size += + ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_elem_type()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto_Tensor::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto_Tensor::MergeFrom(const TypeProto_Tensor &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Tensor) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom( + from._internal_shape()); + } + if (cached_has_bits & 0x00000002u) { + elem_type_ = from.elem_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto_Tensor::CopyFrom(const TypeProto_Tensor &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Tensor) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_Tensor::IsInitialized() const { return true; } + +void TypeProto_Tensor::InternalSwap(TypeProto_Tensor *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, elem_type_) + + sizeof(TypeProto_Tensor::elem_type_) - + PROTOBUF_FIELD_OFFSET(TypeProto_Tensor, shape_)>( + reinterpret_cast(&shape_), + reinterpret_cast(&other->shape_)); +} + +std::string TypeProto_Tensor::GetTypeName() const { + return "onnx.TypeProto.Tensor"; +} + +// =================================================================== + +class TypeProto_Sequence::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::onnx::TypeProto &elem_type(const TypeProto_Sequence *msg); + static void set_has_elem_type(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TypeProto & +TypeProto_Sequence::_Internal::elem_type(const TypeProto_Sequence *msg) { + return *msg->elem_type_; +} +TypeProto_Sequence::TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Sequence) +} +TypeProto_Sequence::TypeProto_Sequence(const TypeProto_Sequence &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_elem_type()) { + elem_type_ = new ::onnx::TypeProto(*from.elem_type_); + } else { + elem_type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Sequence) +} + +inline void TypeProto_Sequence::SharedCtor() { elem_type_ = nullptr; } + +TypeProto_Sequence::~TypeProto_Sequence() { + // @@protoc_insertion_point(destructor:onnx.TypeProto.Sequence) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto_Sequence::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete elem_type_; +} + +void TypeProto_Sequence::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TypeProto_Sequence::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Sequence) + uint32_t 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(elem_type_ != nullptr); + elem_type_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto_Sequence::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .onnx.TypeProto elem_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto_Sequence::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Sequence) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .onnx.TypeProto elem_type = 1; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::elem_type(this), + _Internal::elem_type(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Sequence) + return target; +} + +size_t TypeProto_Sequence::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Sequence) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // optional .onnx.TypeProto elem_type = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *elem_type_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto_Sequence::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto_Sequence::MergeFrom(const TypeProto_Sequence &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Sequence) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_has_elem_type()) { + _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom( + from._internal_elem_type()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto_Sequence::CopyFrom(const TypeProto_Sequence &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Sequence) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_Sequence::IsInitialized() const { return true; } + +void TypeProto_Sequence::InternalSwap(TypeProto_Sequence *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(elem_type_, other->elem_type_); +} + +std::string TypeProto_Sequence::GetTypeName() const { + return "onnx.TypeProto.Sequence"; +} + +// =================================================================== + +class TypeProto_Map::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_key_type(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static const ::onnx::TypeProto &value_type(const TypeProto_Map *msg); + static void set_has_value_type(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TypeProto & +TypeProto_Map::_Internal::value_type(const TypeProto_Map *msg) { + return *msg->value_type_; +} +TypeProto_Map::TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Map) +} +TypeProto_Map::TypeProto_Map(const TypeProto_Map &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_value_type()) { + value_type_ = new ::onnx::TypeProto(*from.value_type_); + } else { + value_type_ = nullptr; + } + key_type_ = from.key_type_; + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Map) +} + +inline void TypeProto_Map::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&value_type_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&key_type_) - + reinterpret_cast(&value_type_)) + + sizeof(key_type_)); +} + +TypeProto_Map::~TypeProto_Map() { + // @@protoc_insertion_point(destructor:onnx.TypeProto.Map) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto_Map::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete value_type_; +} + +void TypeProto_Map::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void TypeProto_Map::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Map) + uint32_t 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(value_type_ != nullptr); + value_type_->Clear(); + } + key_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto_Map::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 key_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_key_type(&has_bits); + key_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TypeProto value_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto_Map::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Map) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 key_type = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_key_type(), target); + } + + // optional .onnx.TypeProto value_type = 2; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::value_type(this), + _Internal::value_type(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Map) + return target; +} + +size_t TypeProto_Map::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Map) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional .onnx.TypeProto value_type = 2; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_type_); + } + + // optional int32 key_type = 1; + if (cached_has_bits & 0x00000002u) { + total_size += + ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_key_type()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto_Map::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto_Map::MergeFrom(const TypeProto_Map &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Map) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_value_type()->::onnx::TypeProto::MergeFrom( + from._internal_value_type()); + } + if (cached_has_bits & 0x00000002u) { + key_type_ = from.key_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto_Map::CopyFrom(const TypeProto_Map &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Map) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_Map::IsInitialized() const { return true; } + +void TypeProto_Map::InternalSwap(TypeProto_Map *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TypeProto_Map, key_type_) + + sizeof(TypeProto_Map::key_type_) - + PROTOBUF_FIELD_OFFSET(TypeProto_Map, value_type_)>( + reinterpret_cast(&value_type_), + reinterpret_cast(&other->value_type_)); +} + +std::string TypeProto_Map::GetTypeName() const { return "onnx.TypeProto.Map"; } + +// =================================================================== + +class TypeProto_Optional::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::onnx::TypeProto &elem_type(const TypeProto_Optional *msg); + static void set_has_elem_type(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TypeProto & +TypeProto_Optional::_Internal::elem_type(const TypeProto_Optional *msg) { + return *msg->elem_type_; +} +TypeProto_Optional::TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.Optional) +} +TypeProto_Optional::TypeProto_Optional(const TypeProto_Optional &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_elem_type()) { + elem_type_ = new ::onnx::TypeProto(*from.elem_type_); + } else { + elem_type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.Optional) +} + +inline void TypeProto_Optional::SharedCtor() { elem_type_ = nullptr; } + +TypeProto_Optional::~TypeProto_Optional() { + // @@protoc_insertion_point(destructor:onnx.TypeProto.Optional) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto_Optional::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete elem_type_; +} + +void TypeProto_Optional::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TypeProto_Optional::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto.Optional) + uint32_t 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(elem_type_ != nullptr); + elem_type_->Clear(); + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto_Optional::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional .onnx.TypeProto elem_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_elem_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto_Optional::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.Optional) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional .onnx.TypeProto elem_type = 1; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::elem_type(this), + _Internal::elem_type(this).GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.Optional) + return target; +} + +size_t TypeProto_Optional::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.Optional) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // optional .onnx.TypeProto elem_type = 1; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *elem_type_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto_Optional::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto_Optional::MergeFrom(const TypeProto_Optional &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.Optional) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_has_elem_type()) { + _internal_mutable_elem_type()->::onnx::TypeProto::MergeFrom( + from._internal_elem_type()); + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto_Optional::CopyFrom(const TypeProto_Optional &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.Optional) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_Optional::IsInitialized() const { return true; } + +void TypeProto_Optional::InternalSwap(TypeProto_Optional *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + swap(elem_type_, other->elem_type_); +} + +std::string TypeProto_Optional::GetTypeName() const { + return "onnx.TypeProto.Optional"; +} + +// =================================================================== + +class TypeProto_SparseTensor::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_elem_type(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static const ::onnx::TensorShapeProto & + shape(const TypeProto_SparseTensor *msg); + static void set_has_shape(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TensorShapeProto & +TypeProto_SparseTensor::_Internal::shape(const TypeProto_SparseTensor *msg) { + return *msg->shape_; +} +TypeProto_SparseTensor::TypeProto_SparseTensor( + ::PROTOBUF_NAMESPACE_ID::Arena *arena, bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto.SparseTensor) +} +TypeProto_SparseTensor::TypeProto_SparseTensor( + const TypeProto_SparseTensor &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + if (from._internal_has_shape()) { + shape_ = new ::onnx::TensorShapeProto(*from.shape_); + } else { + shape_ = nullptr; + } + elem_type_ = from.elem_type_; + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto.SparseTensor) +} + +inline void TypeProto_SparseTensor::SharedCtor() { + ::memset(reinterpret_cast(this) + + static_cast(reinterpret_cast(&shape_) - + reinterpret_cast(this)), + 0, + static_cast(reinterpret_cast(&elem_type_) - + reinterpret_cast(&shape_)) + + sizeof(elem_type_)); +} + +TypeProto_SparseTensor::~TypeProto_SparseTensor() { + // @@protoc_insertion_point(destructor:onnx.TypeProto.SparseTensor) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto_SparseTensor::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) + delete shape_; +} + +void TypeProto_SparseTensor::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void TypeProto_SparseTensor::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto.SparseTensor) + uint32_t 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_ != nullptr); + shape_->Clear(); + } + elem_type_ = 0; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto_SparseTensor::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional int32 elem_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _Internal::set_has_elem_type(&has_bits); + elem_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional .onnx.TensorShapeProto shape = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_shape(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto_SparseTensor::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto.SparseTensor) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional int32 elem_type = 1; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt32ToArray( + 1, this->_internal_elem_type(), target); + } + + // optional .onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 2, _Internal::shape(this), _Internal::shape(this).GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto.SparseTensor) + return target; +} + +size_t TypeProto_SparseTensor::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto.SparseTensor) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional .onnx.TensorShapeProto shape = 2; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(*shape_); + } + + // optional int32 elem_type = 1; + if (cached_has_bits & 0x00000002u) { + total_size += + ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_elem_type()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto_SparseTensor::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto_SparseTensor::MergeFrom(const TypeProto_SparseTensor &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto.SparseTensor) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_mutable_shape()->::onnx::TensorShapeProto::MergeFrom( + from._internal_shape()); + } + if (cached_has_bits & 0x00000002u) { + elem_type_ = from.elem_type_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto_SparseTensor::CopyFrom(const TypeProto_SparseTensor &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto.SparseTensor) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto_SparseTensor::IsInitialized() const { return true; } + +void TypeProto_SparseTensor::InternalSwap(TypeProto_SparseTensor *other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, elem_type_) + + sizeof(TypeProto_SparseTensor::elem_type_) - + PROTOBUF_FIELD_OFFSET(TypeProto_SparseTensor, shape_)>( + reinterpret_cast(&shape_), + reinterpret_cast(&other->shape_)); +} + +std::string TypeProto_SparseTensor::GetTypeName() const { + return "onnx.TypeProto.SparseTensor"; +} + +// =================================================================== + +class TypeProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static const ::onnx::TypeProto_Tensor &tensor_type(const TypeProto *msg); + static const ::onnx::TypeProto_Sequence &sequence_type(const TypeProto *msg); + static const ::onnx::TypeProto_Map &map_type(const TypeProto *msg); + static const ::onnx::TypeProto_Optional &optional_type(const TypeProto *msg); + static const ::onnx::TypeProto_SparseTensor & + sparse_tensor_type(const TypeProto *msg); + static void set_has_denotation(HasBits *has_bits) { (*has_bits)[0] |= 1u; } +}; + +const ::onnx::TypeProto_Tensor & +TypeProto::_Internal::tensor_type(const TypeProto *msg) { + return *msg->value_.tensor_type_; +} +const ::onnx::TypeProto_Sequence & +TypeProto::_Internal::sequence_type(const TypeProto *msg) { + return *msg->value_.sequence_type_; +} +const ::onnx::TypeProto_Map & +TypeProto::_Internal::map_type(const TypeProto *msg) { + return *msg->value_.map_type_; +} +const ::onnx::TypeProto_Optional & +TypeProto::_Internal::optional_type(const TypeProto *msg) { + return *msg->value_.optional_type_; +} +const ::onnx::TypeProto_SparseTensor & +TypeProto::_Internal::sparse_tensor_type(const TypeProto *msg) { + return *msg->value_.sparse_tensor_type_; +} +void TypeProto::set_allocated_tensor_type( + ::onnx::TypeProto_Tensor *tensor_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + clear_value(); + if (tensor_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tensor_type); + if (message_arena != submessage_arena) { + tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, tensor_type, submessage_arena); + } + set_has_tensor_type(); + value_.tensor_type_ = tensor_type; + } + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.tensor_type) +} +void TypeProto::set_allocated_sequence_type( + ::onnx::TypeProto_Sequence *sequence_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + clear_value(); + if (sequence_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sequence_type); + if (message_arena != submessage_arena) { + sequence_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sequence_type, submessage_arena); + } + set_has_sequence_type(); + value_.sequence_type_ = sequence_type; + } + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sequence_type) +} +void TypeProto::set_allocated_map_type(::onnx::TypeProto_Map *map_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + clear_value(); + if (map_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(map_type); + if (message_arena != submessage_arena) { + map_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map_type, submessage_arena); + } + set_has_map_type(); + value_.map_type_ = map_type; + } + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.map_type) +} +void TypeProto::set_allocated_optional_type( + ::onnx::TypeProto_Optional *optional_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + clear_value(); + if (optional_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(optional_type); + if (message_arena != submessage_arena) { + optional_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, optional_type, submessage_arena); + } + set_has_optional_type(); + value_.optional_type_ = optional_type; + } + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.optional_type) +} +void TypeProto::set_allocated_sparse_tensor_type( + ::onnx::TypeProto_SparseTensor *sparse_tensor_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + clear_value(); + if (sparse_tensor_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + sparse_tensor_type); + if (message_arena != submessage_arena) { + sparse_tensor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sparse_tensor_type, submessage_arena); + } + set_has_sparse_tensor_type(); + value_.sparse_tensor_type_ = sparse_tensor_type; + } + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.sparse_tensor_type) +} +TypeProto::TypeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.TypeProto) +} +TypeProto::TypeProto(const TypeProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + denotation_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + denotation_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_denotation()) { + denotation_.Set(from._internal_denotation(), GetArenaForAllocation()); + } + clear_has_value(); + switch (from.value_case()) { + case kTensorType: { + _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom( + from._internal_tensor_type()); + break; + } + case kSequenceType: { + _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom( + from._internal_sequence_type()); + break; + } + case kMapType: { + _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom( + from._internal_map_type()); + break; + } + case kOptionalType: { + _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom( + from._internal_optional_type()); + break; + } + case kSparseTensorType: { + _internal_mutable_sparse_tensor_type() + ->::onnx::TypeProto_SparseTensor::MergeFrom( + from._internal_sparse_tensor_type()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:onnx.TypeProto) +} + +inline void TypeProto::SharedCtor() { + denotation_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + denotation_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + clear_has_value(); +} + +TypeProto::~TypeProto() { + // @@protoc_insertion_point(destructor:onnx.TypeProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void TypeProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + denotation_.Destroy(); + if (has_value()) { + clear_value(); + } +} + +void TypeProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void TypeProto::clear_value() { + // @@protoc_insertion_point(one_of_clear_start:onnx.TypeProto) + switch (value_case()) { + case kTensorType: { + if (GetArenaForAllocation() == nullptr) { + delete value_.tensor_type_; + } + break; + } + case kSequenceType: { + if (GetArenaForAllocation() == nullptr) { + delete value_.sequence_type_; + } + break; + } + case kMapType: { + if (GetArenaForAllocation() == nullptr) { + delete value_.map_type_; + } + break; + } + case kOptionalType: { + if (GetArenaForAllocation() == nullptr) { + delete value_.optional_type_; + } + break; + } + case kSparseTensorType: { + if (GetArenaForAllocation() == nullptr) { + delete value_.sparse_tensor_type_; + } + break; + } + case VALUE_NOT_SET: { + break; + } + } + _oneof_case_[0] = VALUE_NOT_SET; +} + +void TypeProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.TypeProto) + uint32_t 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) { + denotation_.ClearNonDefaultToEmpty(); + } + clear_value(); + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *TypeProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .onnx.TypeProto.Tensor tensor_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_tensor_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .onnx.TypeProto.Sequence sequence_type = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_sequence_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .onnx.TypeProto.Map map_type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_map_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional string denotation = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + auto str = _internal_mutable_denotation(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_sparse_tensor_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // .onnx.TypeProto.Optional optional_type = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_optional_type(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *TypeProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.TypeProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (value_case()) { + case kTensorType: { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 1, _Internal::tensor_type(this), + _Internal::tensor_type(this).GetCachedSize(), target, stream); + break; + } + case kSequenceType: { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 4, _Internal::sequence_type(this), + _Internal::sequence_type(this).GetCachedSize(), target, stream); + break; + } + case kMapType: { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 5, _Internal::map_type(this), _Internal::map_type(this).GetCachedSize(), + target, stream); + break; + } + default:; + } + cached_has_bits = _has_bits_[0]; + // optional string denotation = 6; + if (cached_has_bits & 0x00000001u) { + target = + stream->WriteStringMaybeAliased(6, this->_internal_denotation(), target); + } + + switch (value_case()) { + case kSparseTensorType: { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 8, _Internal::sparse_tensor_type(this), + _Internal::sparse_tensor_type(this).GetCachedSize(), target, stream); + break; + } + case kOptionalType: { + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 9, _Internal::optional_type(this), + _Internal::optional_type(this).GetCachedSize(), target, stream); + break; + } + default:; + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.TypeProto) + return target; +} + +size_t TypeProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.TypeProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // optional string denotation = 6; + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_denotation()); + } + + switch (value_case()) { + // .onnx.TypeProto.Tensor tensor_type = 1; + case kTensorType: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.tensor_type_); + break; + } + // .onnx.TypeProto.Sequence sequence_type = 4; + case kSequenceType: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.sequence_type_); + break; + } + // .onnx.TypeProto.Map map_type = 5; + case kMapType: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.map_type_); + break; + } + // .onnx.TypeProto.Optional optional_type = 9; + case kOptionalType: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.optional_type_); + break; + } + // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8; + case kSparseTensorType: { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_.sparse_tensor_type_); + break; + } + case VALUE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void TypeProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void TypeProto::MergeFrom(const TypeProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.TypeProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (from._internal_has_denotation()) { + _internal_set_denotation(from._internal_denotation()); + } + switch (from.value_case()) { + case kTensorType: { + _internal_mutable_tensor_type()->::onnx::TypeProto_Tensor::MergeFrom( + from._internal_tensor_type()); + break; + } + case kSequenceType: { + _internal_mutable_sequence_type()->::onnx::TypeProto_Sequence::MergeFrom( + from._internal_sequence_type()); + break; + } + case kMapType: { + _internal_mutable_map_type()->::onnx::TypeProto_Map::MergeFrom( + from._internal_map_type()); + break; + } + case kOptionalType: { + _internal_mutable_optional_type()->::onnx::TypeProto_Optional::MergeFrom( + from._internal_optional_type()); + break; + } + case kSparseTensorType: { + _internal_mutable_sparse_tensor_type() + ->::onnx::TypeProto_SparseTensor::MergeFrom( + from._internal_sparse_tensor_type()); + break; + } + case VALUE_NOT_SET: { + break; + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TypeProto::CopyFrom(const TypeProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.TypeProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool TypeProto::IsInitialized() const { return true; } + +void TypeProto::InternalSwap(TypeProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &denotation_, lhs_arena, &other->denotation_, rhs_arena); + swap(value_, other->value_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +std::string TypeProto::GetTypeName() const { return "onnx.TypeProto"; } + +// =================================================================== + +class OperatorSetIdProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_domain(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_version(HasBits *has_bits) { (*has_bits)[0] |= 2u; } +}; + +OperatorSetIdProto::OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.OperatorSetIdProto) +} +OperatorSetIdProto::OperatorSetIdProto(const OperatorSetIdProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), _has_bits_(from._has_bits_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_domain()) { + domain_.Set(from._internal_domain(), GetArenaForAllocation()); + } + version_ = from.version_; + // @@protoc_insertion_point(copy_constructor:onnx.OperatorSetIdProto) +} + +inline void OperatorSetIdProto::SharedCtor() { + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + version_ = int64_t{0}; +} + +OperatorSetIdProto::~OperatorSetIdProto() { + // @@protoc_insertion_point(destructor:onnx.OperatorSetIdProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void OperatorSetIdProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + domain_.Destroy(); +} + +void OperatorSetIdProto::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void OperatorSetIdProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.OperatorSetIdProto) + uint32_t 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) { + domain_.ClearNonDefaultToEmpty(); + } + version_ = int64_t{0}; + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *OperatorSetIdProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string domain = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_domain(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // optional int64 version = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _Internal::set_has_version(&has_bits); + version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *OperatorSetIdProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.OperatorSetIdProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string domain = 1; + if (cached_has_bits & 0x00000001u) { + target = + stream->WriteStringMaybeAliased(1, this->_internal_domain(), target); + } + + // optional int64 version = 2; + if (cached_has_bits & 0x00000002u) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray( + 2, this->_internal_version(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.OperatorSetIdProto) + return target; +} + +size_t OperatorSetIdProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.OperatorSetIdProto) + size_t total_size = 0; + + uint32_t 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 & 0x00000003u) { + // optional string domain = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_domain()); + } + + // optional int64 version = 2; + if (cached_has_bits & 0x00000002u) { + total_size += + ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_version()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void OperatorSetIdProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void OperatorSetIdProto::MergeFrom(const OperatorSetIdProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.OperatorSetIdProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x00000003u) { + if (cached_has_bits & 0x00000001u) { + _internal_set_domain(from._internal_domain()); + } + if (cached_has_bits & 0x00000002u) { + version_ = from.version_; + } + _has_bits_[0] |= cached_has_bits; + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void OperatorSetIdProto::CopyFrom(const OperatorSetIdProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.OperatorSetIdProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool OperatorSetIdProto::IsInitialized() const { return true; } + +void OperatorSetIdProto::InternalSwap(OperatorSetIdProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &domain_, lhs_arena, &other->domain_, rhs_arena); + swap(version_, other->version_); +} + +std::string OperatorSetIdProto::GetTypeName() const { + return "onnx.OperatorSetIdProto"; +} + +// =================================================================== + +class FunctionProto::_Internal { +public: + using HasBits = decltype(std::declval()._has_bits_); + static void set_has_name(HasBits *has_bits) { (*has_bits)[0] |= 1u; } + static void set_has_doc_string(HasBits *has_bits) { (*has_bits)[0] |= 2u; } + static void set_has_domain(HasBits *has_bits) { (*has_bits)[0] |= 4u; } + static void set_has_overload(HasBits *has_bits) { (*has_bits)[0] |= 8u; } +}; + +FunctionProto::FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned), + input_(arena), + output_(arena), + attribute_(arena), + node_(arena), + opset_import_(arena), + attribute_proto_(arena), + value_info_(arena), + metadata_props_(arena) { + SharedCtor(); + // @@protoc_insertion_point(arena_constructor:onnx.FunctionProto) +} +FunctionProto::FunctionProto(const FunctionProto &from) : + ::PROTOBUF_NAMESPACE_ID::MessageLite(), + _has_bits_(from._has_bits_), + input_(from.input_), + output_(from.output_), + attribute_(from.attribute_), + node_(from.node_), + opset_import_(from.opset_import_), + attribute_proto_(from.attribute_proto_), + value_info_(from.value_info_), + metadata_props_(from.metadata_props_) { + _internal_metadata_.MergeFrom(from._internal_metadata_); + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_name()) { + name_.Set(from._internal_name(), GetArenaForAllocation()); + } + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_doc_string()) { + doc_string_.Set(from._internal_doc_string(), GetArenaForAllocation()); + } + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_domain()) { + domain_.Set(from._internal_domain(), GetArenaForAllocation()); + } + overload_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (from._internal_has_overload()) { + overload_.Set(from._internal_overload(), GetArenaForAllocation()); + } + // @@protoc_insertion_point(copy_constructor:onnx.FunctionProto) +} + +inline void FunctionProto::SharedCtor() { + name_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + doc_string_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + domain_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.InitDefault(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + overload_.Set("", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING +} + +FunctionProto::~FunctionProto() { + // @@protoc_insertion_point(destructor:onnx.FunctionProto) + if (auto *arena = _internal_metadata_.DeleteReturnArena()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FunctionProto::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + name_.Destroy(); + doc_string_.Destroy(); + domain_.Destroy(); + overload_.Destroy(); +} + +void FunctionProto::SetCachedSize(int size) const { _cached_size_.Set(size); } + +void FunctionProto::Clear() { + // @@protoc_insertion_point(message_clear_start:onnx.FunctionProto) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + input_.Clear(); + output_.Clear(); + attribute_.Clear(); + node_.Clear(); + opset_import_.Clear(); + attribute_proto_.Clear(); + value_info_.Clear(); + metadata_props_.Clear(); + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + name_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000002u) { + doc_string_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000004u) { + domain_.ClearNonDefaultToEmpty(); + } + if (cached_has_bits & 0x00000008u) { + overload_.ClearNonDefaultToEmpty(); + } + } + _has_bits_.Clear(); + _internal_metadata_.Clear(); +} + +const char *FunctionProto::_InternalParse(const char *ptr, + ::_pbi::ParseContext *ctx) { +#define CHK_(x) \ + if (PROTOBUF_PREDICT_FALSE(!(x))) \ + goto failure + _Internal::HasBits has_bits{}; + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // optional string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated string input = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_input(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string output = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_output(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else + goto handle_unusual; + continue; + // repeated string attribute = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_attribute(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.NodeProto node = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_node(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr)); + } else + goto handle_unusual; + continue; + // optional string doc_string = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { + auto str = _internal_mutable_doc_string(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.OperatorSetIdProto opset_import = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_opset_import(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr)); + } else + goto handle_unusual; + continue; + // optional string domain = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { + auto str = _internal_mutable_domain(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.AttributeProto attribute_proto = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_attribute_proto(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<90>(ptr)); + } else + goto handle_unusual; + continue; + // repeated .onnx.ValueInfoProto value_info = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_value_info(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); + } else + goto handle_unusual; + continue; + // optional string overload = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { + auto str = _internal_mutable_overload(); + ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated .onnx.StringStringEntryProto metadata_props = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_metadata_props(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) + break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr)); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, _internal_metadata_.mutable_unknown_fields(), ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + _has_bits_.Or(has_bits); + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t *FunctionProto::_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const { + // @@protoc_insertion_point(serialize_to_array_start:onnx.FunctionProto) + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = _has_bits_[0]; + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + target = stream->WriteStringMaybeAliased(1, this->_internal_name(), target); + } + + // repeated string input = 4; + for (int i = 0, n = this->_internal_input_size(); i < n; i++) { + const auto &s = this->_internal_input(i); + target = stream->WriteString(4, s, target); + } + + // repeated string output = 5; + for (int i = 0, n = this->_internal_output_size(); i < n; i++) { + const auto &s = this->_internal_output(i); + target = stream->WriteString(5, s, target); + } + + // repeated string attribute = 6; + for (int i = 0, n = this->_internal_attribute_size(); i < n; i++) { + const auto &s = this->_internal_attribute(i); + target = stream->WriteString(6, s, target); + } + + // repeated .onnx.NodeProto node = 7; + for (unsigned i = 0, n = static_cast(this->_internal_node_size()); + i < n; i++) { + const auto &repfield = this->_internal_node(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 7, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string doc_string = 8; + if (cached_has_bits & 0x00000002u) { + target = + stream->WriteStringMaybeAliased(8, this->_internal_doc_string(), target); + } + + // repeated .onnx.OperatorSetIdProto opset_import = 9; + for (unsigned i = 0, + n = static_cast(this->_internal_opset_import_size()); + i < n; i++) { + const auto &repfield = this->_internal_opset_import(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 9, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string domain = 10; + if (cached_has_bits & 0x00000004u) { + target = + stream->WriteStringMaybeAliased(10, this->_internal_domain(), target); + } + + // repeated .onnx.AttributeProto attribute_proto = 11; + for (unsigned i = 0, n = static_cast( + this->_internal_attribute_proto_size()); + i < n; i++) { + const auto &repfield = this->_internal_attribute_proto(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 11, repfield, repfield.GetCachedSize(), target, stream); + } + + // repeated .onnx.ValueInfoProto value_info = 12; + for (unsigned i = 0, + n = static_cast(this->_internal_value_info_size()); + i < n; i++) { + const auto &repfield = this->_internal_value_info(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 12, repfield, repfield.GetCachedSize(), target, stream); + } + + // optional string overload = 13; + if (cached_has_bits & 0x00000008u) { + target = + stream->WriteStringMaybeAliased(13, this->_internal_overload(), target); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + for (unsigned i = 0, n = static_cast( + this->_internal_metadata_props_size()); + i < n; i++) { + const auto &repfield = this->_internal_metadata_props(i); + target = + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::InternalWriteMessage( + 14, repfield, repfield.GetCachedSize(), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .data(), + static_cast(_internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size()), + target); + } + // @@protoc_insertion_point(serialize_to_array_end:onnx.FunctionProto) + return target; +} + +size_t FunctionProto::ByteSizeLong() const { + // @@protoc_insertion_point(message_byte_size_start:onnx.FunctionProto) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + // repeated string input = 4; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size()); + for (int i = 0, n = input_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + input_.Get(i)); + } + + // repeated string output = 5; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(output_.size()); + for (int i = 0, n = output_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + output_.Get(i)); + } + + // repeated string attribute = 6; + total_size += + 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(attribute_.size()); + for (int i = 0, n = attribute_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + attribute_.Get(i)); + } + + // repeated .onnx.NodeProto node = 7; + total_size += 1UL * this->_internal_node_size(); + for (const auto &msg : this->node_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.OperatorSetIdProto opset_import = 9; + total_size += 1UL * this->_internal_opset_import_size(); + for (const auto &msg : this->opset_import_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.AttributeProto attribute_proto = 11; + total_size += 1UL * this->_internal_attribute_proto_size(); + for (const auto &msg : this->attribute_proto_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.ValueInfoProto value_info = 12; + total_size += 1UL * this->_internal_value_info_size(); + for (const auto &msg : this->value_info_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + total_size += 1UL * this->_internal_metadata_props_size(); + for (const auto &msg : this->metadata_props_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + cached_has_bits = _has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + // optional string name = 1; + if (cached_has_bits & 0x00000001u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // optional string doc_string = 8; + if (cached_has_bits & 0x00000002u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_doc_string()); + } + + // optional string domain = 10; + if (cached_has_bits & 0x00000004u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_domain()); + } + + // optional string overload = 13; + if (cached_has_bits & 0x00000008u) { + total_size += + 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_overload()); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + total_size += _internal_metadata_ + .unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString) + .size(); + } + int cached_size = ::_pbi::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionProto::CheckTypeAndMergeFrom( + const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) { + MergeFrom(*::_pbi::DownCast(&from)); +} + +void FunctionProto::MergeFrom(const FunctionProto &from) { + // @@protoc_insertion_point(class_specific_merge_from_start:onnx.FunctionProto) + GOOGLE_DCHECK_NE(&from, this); + uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + input_.MergeFrom(from.input_); + output_.MergeFrom(from.output_); + attribute_.MergeFrom(from.attribute_); + node_.MergeFrom(from.node_); + opset_import_.MergeFrom(from.opset_import_); + attribute_proto_.MergeFrom(from.attribute_proto_); + value_info_.MergeFrom(from.value_info_); + metadata_props_.MergeFrom(from.metadata_props_); + cached_has_bits = from._has_bits_[0]; + if (cached_has_bits & 0x0000000fu) { + if (cached_has_bits & 0x00000001u) { + _internal_set_name(from._internal_name()); + } + if (cached_has_bits & 0x00000002u) { + _internal_set_doc_string(from._internal_doc_string()); + } + if (cached_has_bits & 0x00000004u) { + _internal_set_domain(from._internal_domain()); + } + if (cached_has_bits & 0x00000008u) { + _internal_set_overload(from._internal_overload()); + } + } + _internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void FunctionProto::CopyFrom(const FunctionProto &from) { + // @@protoc_insertion_point(class_specific_copy_from_start:onnx.FunctionProto) + if (&from == this) + return; + Clear(); + MergeFrom(from); +} + +bool FunctionProto::IsInitialized() const { return true; } + +void FunctionProto::InternalSwap(FunctionProto *other) { + using std::swap; + auto *lhs_arena = GetArenaForAllocation(); + auto *rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_has_bits_[0], other->_has_bits_[0]); + input_.InternalSwap(&other->input_); + output_.InternalSwap(&other->output_); + attribute_.InternalSwap(&other->attribute_); + node_.InternalSwap(&other->node_); + opset_import_.InternalSwap(&other->opset_import_); + attribute_proto_.InternalSwap(&other->attribute_proto_); + value_info_.InternalSwap(&other->value_info_); + metadata_props_.InternalSwap(&other->metadata_props_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &name_, lhs_arena, &other->name_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &doc_string_, lhs_arena, &other->doc_string_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &domain_, lhs_arena, &other->domain_, rhs_arena); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &overload_, lhs_arena, &other->overload_, rhs_arena); +} + +std::string FunctionProto::GetTypeName() const { return "onnx.FunctionProto"; } + +// @@protoc_insertion_point(namespace_scope) +} // namespace onnx +PROTOBUF_NAMESPACE_OPEN +template <> +PROTOBUF_NOINLINE ::onnx::AttributeProto * +Arena::CreateMaybeMessage<::onnx::AttributeProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::AttributeProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::ValueInfoProto * +Arena::CreateMaybeMessage<::onnx::ValueInfoProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::ValueInfoProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::NodeProto * +Arena::CreateMaybeMessage<::onnx::NodeProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::NodeProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TrainingInfoProto * +Arena::CreateMaybeMessage<::onnx::TrainingInfoProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TrainingInfoProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::ModelProto * +Arena::CreateMaybeMessage<::onnx::ModelProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::ModelProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::StringStringEntryProto * +Arena::CreateMaybeMessage<::onnx::StringStringEntryProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::StringStringEntryProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TensorAnnotation * +Arena::CreateMaybeMessage<::onnx::TensorAnnotation>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TensorAnnotation>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::GraphProto * +Arena::CreateMaybeMessage<::onnx::GraphProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::GraphProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TensorProto_Segment * +Arena::CreateMaybeMessage<::onnx::TensorProto_Segment>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TensorProto_Segment>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TensorProto * +Arena::CreateMaybeMessage<::onnx::TensorProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TensorProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::SparseTensorProto * +Arena::CreateMaybeMessage<::onnx::SparseTensorProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::SparseTensorProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TensorShapeProto_Dimension * +Arena::CreateMaybeMessage<::onnx::TensorShapeProto_Dimension>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TensorShapeProto_Dimension>( + arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TensorShapeProto * +Arena::CreateMaybeMessage<::onnx::TensorShapeProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TensorShapeProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto_Tensor * +Arena::CreateMaybeMessage<::onnx::TypeProto_Tensor>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto_Tensor>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto_Sequence * +Arena::CreateMaybeMessage<::onnx::TypeProto_Sequence>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto_Sequence>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto_Map * +Arena::CreateMaybeMessage<::onnx::TypeProto_Map>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto_Map>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto_Optional * +Arena::CreateMaybeMessage<::onnx::TypeProto_Optional>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto_Optional>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto_SparseTensor * +Arena::CreateMaybeMessage<::onnx::TypeProto_SparseTensor>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto_SparseTensor>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::TypeProto * +Arena::CreateMaybeMessage<::onnx::TypeProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::TypeProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::OperatorSetIdProto * +Arena::CreateMaybeMessage<::onnx::OperatorSetIdProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::OperatorSetIdProto>(arena); +} +template <> +PROTOBUF_NOINLINE ::onnx::FunctionProto * +Arena::CreateMaybeMessage<::onnx::FunctionProto>(Arena *arena) { + return Arena::CreateMessageInternal<::onnx::FunctionProto>(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/nntrainer/compiler/onnx.pb.h b/nntrainer/compiler/onnx.pb.h new file mode 100644 index 000000000..2001dc17b --- /dev/null +++ b/nntrainer/compiler/onnx.pb.h @@ -0,0 +1,12758 @@ +// SPDX-License-Identifier: Apache-2.0 +/** + * Copyright (C) 2017 ONNX Contributors + * + * @file onnx.pb.h + * @see https://github.com/onnx/onnx + * @author ONNX Contributors + * @bug No known bugs + * @brief ONNX schema file (proto2 version) + * + */ + +#ifndef GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3020000 +#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 3020003 < 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 // IWYU pragma: export +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_onnx_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_onnx_2eproto { + static const uint32_t offsets[]; +}; +namespace onnx { +class AttributeProto; +struct AttributeProtoDefaultTypeInternal; +extern AttributeProtoDefaultTypeInternal _AttributeProto_default_instance_; +class FunctionProto; +struct FunctionProtoDefaultTypeInternal; +extern FunctionProtoDefaultTypeInternal _FunctionProto_default_instance_; +class GraphProto; +struct GraphProtoDefaultTypeInternal; +extern GraphProtoDefaultTypeInternal _GraphProto_default_instance_; +class ModelProto; +struct ModelProtoDefaultTypeInternal; +extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_; +class NodeProto; +struct NodeProtoDefaultTypeInternal; +extern NodeProtoDefaultTypeInternal _NodeProto_default_instance_; +class OperatorSetIdProto; +struct OperatorSetIdProtoDefaultTypeInternal; +extern OperatorSetIdProtoDefaultTypeInternal + _OperatorSetIdProto_default_instance_; +class SparseTensorProto; +struct SparseTensorProtoDefaultTypeInternal; +extern SparseTensorProtoDefaultTypeInternal + _SparseTensorProto_default_instance_; +class StringStringEntryProto; +struct StringStringEntryProtoDefaultTypeInternal; +extern StringStringEntryProtoDefaultTypeInternal + _StringStringEntryProto_default_instance_; +class TensorAnnotation; +struct TensorAnnotationDefaultTypeInternal; +extern TensorAnnotationDefaultTypeInternal _TensorAnnotation_default_instance_; +class TensorProto; +struct TensorProtoDefaultTypeInternal; +extern TensorProtoDefaultTypeInternal _TensorProto_default_instance_; +class TensorProto_Segment; +struct TensorProto_SegmentDefaultTypeInternal; +extern TensorProto_SegmentDefaultTypeInternal + _TensorProto_Segment_default_instance_; +class TensorShapeProto; +struct TensorShapeProtoDefaultTypeInternal; +extern TensorShapeProtoDefaultTypeInternal _TensorShapeProto_default_instance_; +class TensorShapeProto_Dimension; +struct TensorShapeProto_DimensionDefaultTypeInternal; +extern TensorShapeProto_DimensionDefaultTypeInternal + _TensorShapeProto_Dimension_default_instance_; +class TrainingInfoProto; +struct TrainingInfoProtoDefaultTypeInternal; +extern TrainingInfoProtoDefaultTypeInternal + _TrainingInfoProto_default_instance_; +class TypeProto; +struct TypeProtoDefaultTypeInternal; +extern TypeProtoDefaultTypeInternal _TypeProto_default_instance_; +class TypeProto_Map; +struct TypeProto_MapDefaultTypeInternal; +extern TypeProto_MapDefaultTypeInternal _TypeProto_Map_default_instance_; +class TypeProto_Optional; +struct TypeProto_OptionalDefaultTypeInternal; +extern TypeProto_OptionalDefaultTypeInternal + _TypeProto_Optional_default_instance_; +class TypeProto_Sequence; +struct TypeProto_SequenceDefaultTypeInternal; +extern TypeProto_SequenceDefaultTypeInternal + _TypeProto_Sequence_default_instance_; +class TypeProto_SparseTensor; +struct TypeProto_SparseTensorDefaultTypeInternal; +extern TypeProto_SparseTensorDefaultTypeInternal + _TypeProto_SparseTensor_default_instance_; +class TypeProto_Tensor; +struct TypeProto_TensorDefaultTypeInternal; +extern TypeProto_TensorDefaultTypeInternal _TypeProto_Tensor_default_instance_; +class ValueInfoProto; +struct ValueInfoProtoDefaultTypeInternal; +extern ValueInfoProtoDefaultTypeInternal _ValueInfoProto_default_instance_; +} // namespace onnx +PROTOBUF_NAMESPACE_OPEN +template <> +::onnx::AttributeProto * +Arena::CreateMaybeMessage<::onnx::AttributeProto>(Arena *); +template <> +::onnx::FunctionProto * +Arena::CreateMaybeMessage<::onnx::FunctionProto>(Arena *); +template <> +::onnx::GraphProto *Arena::CreateMaybeMessage<::onnx::GraphProto>(Arena *); +template <> +::onnx::ModelProto *Arena::CreateMaybeMessage<::onnx::ModelProto>(Arena *); +template <> +::onnx::NodeProto *Arena::CreateMaybeMessage<::onnx::NodeProto>(Arena *); +template <> +::onnx::OperatorSetIdProto * +Arena::CreateMaybeMessage<::onnx::OperatorSetIdProto>(Arena *); +template <> +::onnx::SparseTensorProto * +Arena::CreateMaybeMessage<::onnx::SparseTensorProto>(Arena *); +template <> +::onnx::StringStringEntryProto * +Arena::CreateMaybeMessage<::onnx::StringStringEntryProto>(Arena *); +template <> +::onnx::TensorAnnotation * +Arena::CreateMaybeMessage<::onnx::TensorAnnotation>(Arena *); +template <> +::onnx::TensorProto *Arena::CreateMaybeMessage<::onnx::TensorProto>(Arena *); +template <> +::onnx::TensorProto_Segment * +Arena::CreateMaybeMessage<::onnx::TensorProto_Segment>(Arena *); +template <> +::onnx::TensorShapeProto * +Arena::CreateMaybeMessage<::onnx::TensorShapeProto>(Arena *); +template <> +::onnx::TensorShapeProto_Dimension * +Arena::CreateMaybeMessage<::onnx::TensorShapeProto_Dimension>(Arena *); +template <> +::onnx::TrainingInfoProto * +Arena::CreateMaybeMessage<::onnx::TrainingInfoProto>(Arena *); +template <> +::onnx::TypeProto *Arena::CreateMaybeMessage<::onnx::TypeProto>(Arena *); +template <> +::onnx::TypeProto_Map * +Arena::CreateMaybeMessage<::onnx::TypeProto_Map>(Arena *); +template <> +::onnx::TypeProto_Optional * +Arena::CreateMaybeMessage<::onnx::TypeProto_Optional>(Arena *); +template <> +::onnx::TypeProto_Sequence * +Arena::CreateMaybeMessage<::onnx::TypeProto_Sequence>(Arena *); +template <> +::onnx::TypeProto_SparseTensor * +Arena::CreateMaybeMessage<::onnx::TypeProto_SparseTensor>(Arena *); +template <> +::onnx::TypeProto_Tensor * +Arena::CreateMaybeMessage<::onnx::TypeProto_Tensor>(Arena *); +template <> +::onnx::ValueInfoProto * +Arena::CreateMaybeMessage<::onnx::ValueInfoProto>(Arena *); +PROTOBUF_NAMESPACE_CLOSE +namespace onnx { + +enum AttributeProto_AttributeType : int { + AttributeProto_AttributeType_UNDEFINED = 0, + AttributeProto_AttributeType_FLOAT = 1, + AttributeProto_AttributeType_INT = 2, + AttributeProto_AttributeType_STRING = 3, + AttributeProto_AttributeType_TENSOR = 4, + AttributeProto_AttributeType_GRAPH = 5, + AttributeProto_AttributeType_SPARSE_TENSOR = 11, + AttributeProto_AttributeType_TYPE_PROTO = 13, + AttributeProto_AttributeType_FLOATS = 6, + AttributeProto_AttributeType_INTS = 7, + AttributeProto_AttributeType_STRINGS = 8, + AttributeProto_AttributeType_TENSORS = 9, + AttributeProto_AttributeType_GRAPHS = 10, + AttributeProto_AttributeType_SPARSE_TENSORS = 12, + AttributeProto_AttributeType_TYPE_PROTOS = 14 +}; +bool AttributeProto_AttributeType_IsValid(int value); +constexpr AttributeProto_AttributeType + AttributeProto_AttributeType_AttributeType_MIN = + AttributeProto_AttributeType_UNDEFINED; +constexpr AttributeProto_AttributeType + AttributeProto_AttributeType_AttributeType_MAX = + AttributeProto_AttributeType_TYPE_PROTOS; +constexpr int AttributeProto_AttributeType_AttributeType_ARRAYSIZE = + AttributeProto_AttributeType_AttributeType_MAX + 1; + +const std::string & +AttributeProto_AttributeType_Name(AttributeProto_AttributeType value); +template +inline const std::string &AttributeProto_AttributeType_Name(T enum_t_value) { + static_assert( + ::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AttributeProto_AttributeType_Name."); + return AttributeProto_AttributeType_Name( + static_cast(enum_t_value)); +} +bool AttributeProto_AttributeType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AttributeProto_AttributeType *value); +enum TensorProto_DataType : int { + TensorProto_DataType_UNDEFINED = 0, + TensorProto_DataType_FLOAT = 1, + TensorProto_DataType_UINT8 = 2, + TensorProto_DataType_INT8 = 3, + TensorProto_DataType_UINT16 = 4, + TensorProto_DataType_INT16 = 5, + TensorProto_DataType_INT32 = 6, + TensorProto_DataType_INT64 = 7, + TensorProto_DataType_STRING = 8, + TensorProto_DataType_BOOL = 9, + TensorProto_DataType_FLOAT16 = 10, + TensorProto_DataType_DOUBLE = 11, + TensorProto_DataType_UINT32 = 12, + TensorProto_DataType_UINT64 = 13, + TensorProto_DataType_COMPLEX64 = 14, + TensorProto_DataType_COMPLEX128 = 15, + TensorProto_DataType_BFLOAT16 = 16, + TensorProto_DataType_FLOAT8E4M3FN = 17, + TensorProto_DataType_FLOAT8E4M3FNUZ = 18, + TensorProto_DataType_FLOAT8E5M2 = 19, + TensorProto_DataType_FLOAT8E5M2FNUZ = 20, + TensorProto_DataType_UINT4 = 21, + TensorProto_DataType_INT4 = 22, + TensorProto_DataType_FLOAT4E2M1 = 23 +}; +bool TensorProto_DataType_IsValid(int value); +constexpr TensorProto_DataType TensorProto_DataType_DataType_MIN = + TensorProto_DataType_UNDEFINED; +constexpr TensorProto_DataType TensorProto_DataType_DataType_MAX = + TensorProto_DataType_FLOAT4E2M1; +constexpr int TensorProto_DataType_DataType_ARRAYSIZE = + TensorProto_DataType_DataType_MAX + 1; + +const std::string &TensorProto_DataType_Name(TensorProto_DataType value); +template +inline const std::string &TensorProto_DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function TensorProto_DataType_Name."); + return TensorProto_DataType_Name( + static_cast(enum_t_value)); +} +bool TensorProto_DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + TensorProto_DataType *value); +enum TensorProto_DataLocation : int { + TensorProto_DataLocation_DEFAULT = 0, + TensorProto_DataLocation_EXTERNAL = 1 +}; +bool TensorProto_DataLocation_IsValid(int value); +constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MIN = + TensorProto_DataLocation_DEFAULT; +constexpr TensorProto_DataLocation TensorProto_DataLocation_DataLocation_MAX = + TensorProto_DataLocation_EXTERNAL; +constexpr int TensorProto_DataLocation_DataLocation_ARRAYSIZE = + TensorProto_DataLocation_DataLocation_MAX + 1; + +const std::string & +TensorProto_DataLocation_Name(TensorProto_DataLocation value); +template +inline const std::string &TensorProto_DataLocation_Name(T enum_t_value) { + static_assert( + ::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function TensorProto_DataLocation_Name."); + return TensorProto_DataLocation_Name( + static_cast(enum_t_value)); +} +bool TensorProto_DataLocation_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + TensorProto_DataLocation *value); +enum Version : int { + _START_VERSION = 0, + IR_VERSION_2017_10_10 = 1, + IR_VERSION_2017_10_30 = 2, + IR_VERSION_2017_11_3 = 3, + IR_VERSION_2019_1_22 = 4, + IR_VERSION_2019_3_18 = 5, + IR_VERSION_2019_9_19 = 6, + IR_VERSION_2020_5_8 = 7, + IR_VERSION_2021_7_30 = 8, + IR_VERSION_2023_5_5 = 9, + IR_VERSION_2024_3_25 = 10, + IR_VERSION = 11 +}; +bool Version_IsValid(int value); +constexpr Version Version_MIN = _START_VERSION; +constexpr Version Version_MAX = IR_VERSION; +constexpr int Version_ARRAYSIZE = Version_MAX + 1; + +const std::string &Version_Name(Version value); +template inline const std::string &Version_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Version_Name."); + return Version_Name(static_cast(enum_t_value)); +} +bool Version_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Version *value); +enum OperatorStatus : int { EXPERIMENTAL = 0, STABLE = 1 }; +bool OperatorStatus_IsValid(int value); +constexpr OperatorStatus OperatorStatus_MIN = EXPERIMENTAL; +constexpr OperatorStatus OperatorStatus_MAX = STABLE; +constexpr int OperatorStatus_ARRAYSIZE = OperatorStatus_MAX + 1; + +const std::string &OperatorStatus_Name(OperatorStatus value); +template +inline const std::string &OperatorStatus_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OperatorStatus_Name."); + return OperatorStatus_Name(static_cast(enum_t_value)); +} +bool OperatorStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OperatorStatus *value); +// =================================================================== + +class AttributeProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.AttributeProto) + */ +{ +public: + inline AttributeProto() : AttributeProto(nullptr) {} + ~AttributeProto() override; + explicit PROTOBUF_CONSTEXPR + AttributeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AttributeProto(const AttributeProto &from); + AttributeProto(AttributeProto &&from) noexcept : AttributeProto() { + *this = ::std::move(from); + } + + inline AttributeProto &operator=(const AttributeProto &from) { + CopyFrom(from); + return *this; + } + inline AttributeProto &operator=(AttributeProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AttributeProto &default_instance() { + return *internal_default_instance(); + } + static inline const AttributeProto *internal_default_instance() { + return reinterpret_cast( + &_AttributeProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + + friend void swap(AttributeProto &a, AttributeProto &b) { a.Swap(&b); } + inline void Swap(AttributeProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AttributeProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AttributeProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const AttributeProto &from); + void MergeFrom(const AttributeProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(AttributeProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.AttributeProto"; + } + +protected: + explicit AttributeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef AttributeProto_AttributeType AttributeType; + static constexpr AttributeType UNDEFINED = + AttributeProto_AttributeType_UNDEFINED; + static constexpr AttributeType FLOAT = AttributeProto_AttributeType_FLOAT; + static constexpr AttributeType INT = AttributeProto_AttributeType_INT; + static constexpr AttributeType STRING = AttributeProto_AttributeType_STRING; + static constexpr AttributeType TENSOR = AttributeProto_AttributeType_TENSOR; + static constexpr AttributeType GRAPH = AttributeProto_AttributeType_GRAPH; + static constexpr AttributeType SPARSE_TENSOR = + AttributeProto_AttributeType_SPARSE_TENSOR; + static constexpr AttributeType TYPE_PROTO = + AttributeProto_AttributeType_TYPE_PROTO; + static constexpr AttributeType FLOATS = AttributeProto_AttributeType_FLOATS; + static constexpr AttributeType INTS = AttributeProto_AttributeType_INTS; + static constexpr AttributeType STRINGS = AttributeProto_AttributeType_STRINGS; + static constexpr AttributeType TENSORS = AttributeProto_AttributeType_TENSORS; + static constexpr AttributeType GRAPHS = AttributeProto_AttributeType_GRAPHS; + static constexpr AttributeType SPARSE_TENSORS = + AttributeProto_AttributeType_SPARSE_TENSORS; + static constexpr AttributeType TYPE_PROTOS = + AttributeProto_AttributeType_TYPE_PROTOS; + static inline bool AttributeType_IsValid(int value) { + return AttributeProto_AttributeType_IsValid(value); + } + static constexpr AttributeType AttributeType_MIN = + AttributeProto_AttributeType_AttributeType_MIN; + static constexpr AttributeType AttributeType_MAX = + AttributeProto_AttributeType_AttributeType_MAX; + static constexpr int AttributeType_ARRAYSIZE = + AttributeProto_AttributeType_AttributeType_ARRAYSIZE; + template + static inline const std::string &AttributeType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AttributeType_Name."); + return AttributeProto_AttributeType_Name(enum_t_value); + } + static inline bool + AttributeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AttributeType *value) { + return AttributeProto_AttributeType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kFloatsFieldNumber = 7, + kIntsFieldNumber = 8, + kStringsFieldNumber = 9, + kTensorsFieldNumber = 10, + kGraphsFieldNumber = 11, + kTypeProtosFieldNumber = 15, + kSparseTensorsFieldNumber = 23, + kNameFieldNumber = 1, + kSFieldNumber = 4, + kDocStringFieldNumber = 13, + kRefAttrNameFieldNumber = 21, + kTFieldNumber = 5, + kGFieldNumber = 6, + kTpFieldNumber = 14, + kSparseTensorFieldNumber = 22, + kIFieldNumber = 3, + kFFieldNumber = 2, + kTypeFieldNumber = 20, + }; + // repeated float floats = 7; + int floats_size() const; + +private: + int _internal_floats_size() const; + +public: + void clear_floats(); + +private: + float _internal_floats(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &_internal_floats() const; + void _internal_add_floats(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField *_internal_mutable_floats(); + +public: + float floats(int index) const; + void set_floats(int index, float value); + void add_floats(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &floats() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_floats(); + + // repeated int64 ints = 8; + int ints_size() const; + +private: + int _internal_ints_size() const; + +public: + void clear_ints(); + +private: + int64_t _internal_ints(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &_internal_ints() const; + void _internal_add_ints(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField *_internal_mutable_ints(); + +public: + int64_t ints(int index) const; + void set_ints(int index, int64_t value); + void add_ints(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &ints() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_ints(); + + // repeated bytes strings = 9; + int strings_size() const; + +private: + int _internal_strings_size() const; + +public: + void clear_strings(); + const std::string &strings(int index) const; + std::string *mutable_strings(int index); + void set_strings(int index, const std::string &value); + void set_strings(int index, std::string &&value); + void set_strings(int index, const char *value); + void set_strings(int index, const void *value, size_t size); + std::string *add_strings(); + void add_strings(const std::string &value); + void add_strings(std::string &&value); + void add_strings(const char *value); + void add_strings(const void *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField &strings() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_strings(); + +private: + const std::string &_internal_strings(int index) const; + std::string *_internal_add_strings(); + +public: + // repeated .onnx.TensorProto tensors = 10; + int tensors_size() const; + +private: + int _internal_tensors_size() const; + +public: + void clear_tensors(); + ::onnx::TensorProto *mutable_tensors(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> * + mutable_tensors(); + +private: + const ::onnx::TensorProto &_internal_tensors(int index) const; + ::onnx::TensorProto *_internal_add_tensors(); + +public: + const ::onnx::TensorProto &tensors(int index) const; + ::onnx::TensorProto *add_tensors(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> & + tensors() const; + + // repeated .onnx.GraphProto graphs = 11; + int graphs_size() const; + +private: + int _internal_graphs_size() const; + +public: + void clear_graphs(); + ::onnx::GraphProto *mutable_graphs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::GraphProto> * + mutable_graphs(); + +private: + const ::onnx::GraphProto &_internal_graphs(int index) const; + ::onnx::GraphProto *_internal_add_graphs(); + +public: + const ::onnx::GraphProto &graphs(int index) const; + ::onnx::GraphProto *add_graphs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::GraphProto> & + graphs() const; + + // repeated .onnx.TypeProto type_protos = 15; + int type_protos_size() const; + +private: + int _internal_type_protos_size() const; + +public: + void clear_type_protos(); + ::onnx::TypeProto *mutable_type_protos(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TypeProto> * + mutable_type_protos(); + +private: + const ::onnx::TypeProto &_internal_type_protos(int index) const; + ::onnx::TypeProto *_internal_add_type_protos(); + +public: + const ::onnx::TypeProto &type_protos(int index) const; + ::onnx::TypeProto *add_type_protos(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TypeProto> & + type_protos() const; + + // repeated .onnx.SparseTensorProto sparse_tensors = 23; + int sparse_tensors_size() const; + +private: + int _internal_sparse_tensors_size() const; + +public: + void clear_sparse_tensors(); + ::onnx::SparseTensorProto *mutable_sparse_tensors(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> * + mutable_sparse_tensors(); + +private: + const ::onnx::SparseTensorProto &_internal_sparse_tensors(int index) const; + ::onnx::SparseTensorProto *_internal_add_sparse_tensors(); + +public: + const ::onnx::SparseTensorProto &sparse_tensors(int index) const; + ::onnx::SparseTensorProto *add_sparse_tensors(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> & + sparse_tensors() const; + + // optional string name = 1; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional bytes s = 4; + bool has_s() const; + +private: + bool _internal_has_s() const; + +public: + void clear_s(); + const std::string &s() const; + template + void set_s(ArgT0 &&arg0, ArgT... args); + std::string *mutable_s(); + PROTOBUF_NODISCARD std::string *release_s(); + void set_allocated_s(std::string *s); + +private: + const std::string &_internal_s() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_s(const std::string &value); + std::string *_internal_mutable_s(); + +public: + // optional string doc_string = 13; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional string ref_attr_name = 21; + bool has_ref_attr_name() const; + +private: + bool _internal_has_ref_attr_name() const; + +public: + void clear_ref_attr_name(); + const std::string &ref_attr_name() const; + template + void set_ref_attr_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_ref_attr_name(); + PROTOBUF_NODISCARD std::string *release_ref_attr_name(); + void set_allocated_ref_attr_name(std::string *ref_attr_name); + +private: + const std::string &_internal_ref_attr_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_ref_attr_name(const std::string &value); + std::string *_internal_mutable_ref_attr_name(); + +public: + // optional .onnx.TensorProto t = 5; + bool has_t() const; + +private: + bool _internal_has_t() const; + +public: + void clear_t(); + const ::onnx::TensorProto &t() const; + PROTOBUF_NODISCARD ::onnx::TensorProto *release_t(); + ::onnx::TensorProto *mutable_t(); + void set_allocated_t(::onnx::TensorProto *t); + +private: + const ::onnx::TensorProto &_internal_t() const; + ::onnx::TensorProto *_internal_mutable_t(); + +public: + void unsafe_arena_set_allocated_t(::onnx::TensorProto *t); + ::onnx::TensorProto *unsafe_arena_release_t(); + + // optional .onnx.GraphProto g = 6; + bool has_g() const; + +private: + bool _internal_has_g() const; + +public: + void clear_g(); + const ::onnx::GraphProto &g() const; + PROTOBUF_NODISCARD ::onnx::GraphProto *release_g(); + ::onnx::GraphProto *mutable_g(); + void set_allocated_g(::onnx::GraphProto *g); + +private: + const ::onnx::GraphProto &_internal_g() const; + ::onnx::GraphProto *_internal_mutable_g(); + +public: + void unsafe_arena_set_allocated_g(::onnx::GraphProto *g); + ::onnx::GraphProto *unsafe_arena_release_g(); + + // optional .onnx.TypeProto tp = 14; + bool has_tp() const; + +private: + bool _internal_has_tp() const; + +public: + void clear_tp(); + const ::onnx::TypeProto &tp() const; + PROTOBUF_NODISCARD ::onnx::TypeProto *release_tp(); + ::onnx::TypeProto *mutable_tp(); + void set_allocated_tp(::onnx::TypeProto *tp); + +private: + const ::onnx::TypeProto &_internal_tp() const; + ::onnx::TypeProto *_internal_mutable_tp(); + +public: + void unsafe_arena_set_allocated_tp(::onnx::TypeProto *tp); + ::onnx::TypeProto *unsafe_arena_release_tp(); + + // optional .onnx.SparseTensorProto sparse_tensor = 22; + bool has_sparse_tensor() const; + +private: + bool _internal_has_sparse_tensor() const; + +public: + void clear_sparse_tensor(); + const ::onnx::SparseTensorProto &sparse_tensor() const; + PROTOBUF_NODISCARD ::onnx::SparseTensorProto *release_sparse_tensor(); + ::onnx::SparseTensorProto *mutable_sparse_tensor(); + void set_allocated_sparse_tensor(::onnx::SparseTensorProto *sparse_tensor); + +private: + const ::onnx::SparseTensorProto &_internal_sparse_tensor() const; + ::onnx::SparseTensorProto *_internal_mutable_sparse_tensor(); + +public: + void unsafe_arena_set_allocated_sparse_tensor( + ::onnx::SparseTensorProto *sparse_tensor); + ::onnx::SparseTensorProto *unsafe_arena_release_sparse_tensor(); + + // optional int64 i = 3; + bool has_i() const; + +private: + bool _internal_has_i() const; + +public: + void clear_i(); + int64_t i() const; + void set_i(int64_t value); + +private: + int64_t _internal_i() const; + void _internal_set_i(int64_t value); + +public: + // optional float f = 2; + bool has_f() const; + +private: + bool _internal_has_f() const; + +public: + void clear_f(); + float f() const; + void set_f(float value); + +private: + float _internal_f() const; + void _internal_set_f(float value); + +public: + // optional .onnx.AttributeProto.AttributeType type = 20; + bool has_type() const; + +private: + bool _internal_has_type() const; + +public: + void clear_type(); + ::onnx::AttributeProto_AttributeType type() const; + void set_type(::onnx::AttributeProto_AttributeType value); + +private: + ::onnx::AttributeProto_AttributeType _internal_type() const; + void _internal_set_type(::onnx::AttributeProto_AttributeType value); + +public: + // @@protoc_insertion_point(class_scope:onnx.AttributeProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField floats_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField ints_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField strings_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> tensors_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::GraphProto> graphs_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TypeProto> type_protos_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> + sparse_tensors_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr s_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ref_attr_name_; + ::onnx::TensorProto *t_; + ::onnx::GraphProto *g_; + ::onnx::TypeProto *tp_; + ::onnx::SparseTensorProto *sparse_tensor_; + int64_t i_; + float f_; + int type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class ValueInfoProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.ValueInfoProto) + */ +{ +public: + inline ValueInfoProto() : ValueInfoProto(nullptr) {} + ~ValueInfoProto() override; + explicit PROTOBUF_CONSTEXPR + ValueInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ValueInfoProto(const ValueInfoProto &from); + ValueInfoProto(ValueInfoProto &&from) noexcept : ValueInfoProto() { + *this = ::std::move(from); + } + + inline ValueInfoProto &operator=(const ValueInfoProto &from) { + CopyFrom(from); + return *this; + } + inline ValueInfoProto &operator=(ValueInfoProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ValueInfoProto &default_instance() { + return *internal_default_instance(); + } + static inline const ValueInfoProto *internal_default_instance() { + return reinterpret_cast( + &_ValueInfoProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + + friend void swap(ValueInfoProto &a, ValueInfoProto &b) { a.Swap(&b); } + inline void Swap(ValueInfoProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ValueInfoProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ValueInfoProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const ValueInfoProto &from); + void MergeFrom(const ValueInfoProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ValueInfoProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.ValueInfoProto"; + } + +protected: + explicit ValueInfoProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMetadataPropsFieldNumber = 4, + kNameFieldNumber = 1, + kDocStringFieldNumber = 3, + kTypeFieldNumber = 2, + }; + // repeated .onnx.StringStringEntryProto metadata_props = 4; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // optional string name = 1; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional string doc_string = 3; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional .onnx.TypeProto type = 2; + bool has_type() const; + +private: + bool _internal_has_type() const; + +public: + void clear_type(); + const ::onnx::TypeProto &type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto *release_type(); + ::onnx::TypeProto *mutable_type(); + void set_allocated_type(::onnx::TypeProto *type); + +private: + const ::onnx::TypeProto &_internal_type() const; + ::onnx::TypeProto *_internal_mutable_type(); + +public: + void unsafe_arena_set_allocated_type(::onnx::TypeProto *type); + ::onnx::TypeProto *unsafe_arena_release_type(); + + // @@protoc_insertion_point(class_scope:onnx.ValueInfoProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::onnx::TypeProto *type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class NodeProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.NodeProto) + */ +{ +public: + inline NodeProto() : NodeProto(nullptr) {} + ~NodeProto() override; + explicit PROTOBUF_CONSTEXPR + NodeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + NodeProto(const NodeProto &from); + NodeProto(NodeProto &&from) noexcept : NodeProto() { + *this = ::std::move(from); + } + + inline NodeProto &operator=(const NodeProto &from) { + CopyFrom(from); + return *this; + } + inline NodeProto &operator=(NodeProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const NodeProto &default_instance() { + return *internal_default_instance(); + } + static inline const NodeProto *internal_default_instance() { + return reinterpret_cast(&_NodeProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + + friend void swap(NodeProto &a, NodeProto &b) { a.Swap(&b); } + inline void Swap(NodeProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(NodeProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + NodeProto *New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const NodeProto &from); + void MergeFrom(const NodeProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(NodeProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.NodeProto"; + } + +protected: + explicit NodeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInputFieldNumber = 1, + kOutputFieldNumber = 2, + kAttributeFieldNumber = 5, + kMetadataPropsFieldNumber = 9, + kNameFieldNumber = 3, + kOpTypeFieldNumber = 4, + kDocStringFieldNumber = 6, + kDomainFieldNumber = 7, + kOverloadFieldNumber = 8, + }; + // repeated string input = 1; + int input_size() const; + +private: + int _internal_input_size() const; + +public: + void clear_input(); + const std::string &input(int index) const; + std::string *mutable_input(int index); + void set_input(int index, const std::string &value); + void set_input(int index, std::string &&value); + void set_input(int index, const char *value); + void set_input(int index, const char *value, size_t size); + std::string *add_input(); + void add_input(const std::string &value); + void add_input(std::string &&value); + void add_input(const char *value); + void add_input(const char *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField &input() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_input(); + +private: + const std::string &_internal_input(int index) const; + std::string *_internal_add_input(); + +public: + // repeated string output = 2; + int output_size() const; + +private: + int _internal_output_size() const; + +public: + void clear_output(); + const std::string &output(int index) const; + std::string *mutable_output(int index); + void set_output(int index, const std::string &value); + void set_output(int index, std::string &&value); + void set_output(int index, const char *value); + void set_output(int index, const char *value, size_t size); + std::string *add_output(); + void add_output(const std::string &value); + void add_output(std::string &&value); + void add_output(const char *value); + void add_output(const char *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField &output() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_output(); + +private: + const std::string &_internal_output(int index) const; + std::string *_internal_add_output(); + +public: + // repeated .onnx.AttributeProto attribute = 5; + int attribute_size() const; + +private: + int _internal_attribute_size() const; + +public: + void clear_attribute(); + ::onnx::AttributeProto *mutable_attribute(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> * + mutable_attribute(); + +private: + const ::onnx::AttributeProto &_internal_attribute(int index) const; + ::onnx::AttributeProto *_internal_add_attribute(); + +public: + const ::onnx::AttributeProto &attribute(int index) const; + ::onnx::AttributeProto *add_attribute(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> & + attribute() const; + + // repeated .onnx.StringStringEntryProto metadata_props = 9; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // optional string name = 3; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional string op_type = 4; + bool has_op_type() const; + +private: + bool _internal_has_op_type() const; + +public: + void clear_op_type(); + const std::string &op_type() const; + template + void set_op_type(ArgT0 &&arg0, ArgT... args); + std::string *mutable_op_type(); + PROTOBUF_NODISCARD std::string *release_op_type(); + void set_allocated_op_type(std::string *op_type); + +private: + const std::string &_internal_op_type() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_op_type(const std::string &value); + std::string *_internal_mutable_op_type(); + +public: + // optional string doc_string = 6; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional string domain = 7; + bool has_domain() const; + +private: + bool _internal_has_domain() const; + +public: + void clear_domain(); + const std::string &domain() const; + template + void set_domain(ArgT0 &&arg0, ArgT... args); + std::string *mutable_domain(); + PROTOBUF_NODISCARD std::string *release_domain(); + void set_allocated_domain(std::string *domain); + +private: + const std::string &_internal_domain() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_domain(const std::string &value); + std::string *_internal_mutable_domain(); + +public: + // optional string overload = 8; + bool has_overload() const; + +private: + bool _internal_has_overload() const; + +public: + void clear_overload(); + const std::string &overload() const; + template + void set_overload(ArgT0 &&arg0, ArgT... args); + std::string *mutable_overload(); + PROTOBUF_NODISCARD std::string *release_overload(); + void set_allocated_overload(std::string *overload); + +private: + const std::string &_internal_overload() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_overload(const std::string &value); + std::string *_internal_mutable_overload(); + +public: + // @@protoc_insertion_point(class_scope:onnx.NodeProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField input_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField output_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> attribute_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TrainingInfoProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TrainingInfoProto) + */ +{ +public: + inline TrainingInfoProto() : TrainingInfoProto(nullptr) {} + ~TrainingInfoProto() override; + explicit PROTOBUF_CONSTEXPR + TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TrainingInfoProto(const TrainingInfoProto &from); + TrainingInfoProto(TrainingInfoProto &&from) noexcept : TrainingInfoProto() { + *this = ::std::move(from); + } + + inline TrainingInfoProto &operator=(const TrainingInfoProto &from) { + CopyFrom(from); + return *this; + } + inline TrainingInfoProto &operator=(TrainingInfoProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TrainingInfoProto &default_instance() { + return *internal_default_instance(); + } + static inline const TrainingInfoProto *internal_default_instance() { + return reinterpret_cast( + &_TrainingInfoProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + + friend void swap(TrainingInfoProto &a, TrainingInfoProto &b) { a.Swap(&b); } + inline void Swap(TrainingInfoProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TrainingInfoProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TrainingInfoProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TrainingInfoProto &from); + void MergeFrom(const TrainingInfoProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TrainingInfoProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TrainingInfoProto"; + } + +protected: + explicit TrainingInfoProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInitializationBindingFieldNumber = 3, + kUpdateBindingFieldNumber = 4, + kInitializationFieldNumber = 1, + kAlgorithmFieldNumber = 2, + }; + // repeated .onnx.StringStringEntryProto initialization_binding = 3; + int initialization_binding_size() const; + +private: + int _internal_initialization_binding_size() const; + +public: + void clear_initialization_binding(); + ::onnx::StringStringEntryProto *mutable_initialization_binding(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_initialization_binding(); + +private: + const ::onnx::StringStringEntryProto & + _internal_initialization_binding(int index) const; + ::onnx::StringStringEntryProto *_internal_add_initialization_binding(); + +public: + const ::onnx::StringStringEntryProto &initialization_binding(int index) const; + ::onnx::StringStringEntryProto *add_initialization_binding(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + initialization_binding() const; + + // repeated .onnx.StringStringEntryProto update_binding = 4; + int update_binding_size() const; + +private: + int _internal_update_binding_size() const; + +public: + void clear_update_binding(); + ::onnx::StringStringEntryProto *mutable_update_binding(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_update_binding(); + +private: + const ::onnx::StringStringEntryProto & + _internal_update_binding(int index) const; + ::onnx::StringStringEntryProto *_internal_add_update_binding(); + +public: + const ::onnx::StringStringEntryProto &update_binding(int index) const; + ::onnx::StringStringEntryProto *add_update_binding(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + update_binding() const; + + // optional .onnx.GraphProto initialization = 1; + bool has_initialization() const; + +private: + bool _internal_has_initialization() const; + +public: + void clear_initialization(); + const ::onnx::GraphProto &initialization() const; + PROTOBUF_NODISCARD ::onnx::GraphProto *release_initialization(); + ::onnx::GraphProto *mutable_initialization(); + void set_allocated_initialization(::onnx::GraphProto *initialization); + +private: + const ::onnx::GraphProto &_internal_initialization() const; + ::onnx::GraphProto *_internal_mutable_initialization(); + +public: + void + unsafe_arena_set_allocated_initialization(::onnx::GraphProto *initialization); + ::onnx::GraphProto *unsafe_arena_release_initialization(); + + // optional .onnx.GraphProto algorithm = 2; + bool has_algorithm() const; + +private: + bool _internal_has_algorithm() const; + +public: + void clear_algorithm(); + const ::onnx::GraphProto &algorithm() const; + PROTOBUF_NODISCARD ::onnx::GraphProto *release_algorithm(); + ::onnx::GraphProto *mutable_algorithm(); + void set_allocated_algorithm(::onnx::GraphProto *algorithm); + +private: + const ::onnx::GraphProto &_internal_algorithm() const; + ::onnx::GraphProto *_internal_mutable_algorithm(); + +public: + void unsafe_arena_set_allocated_algorithm(::onnx::GraphProto *algorithm); + ::onnx::GraphProto *unsafe_arena_release_algorithm(); + + // @@protoc_insertion_point(class_scope:onnx.TrainingInfoProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + initialization_binding_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + update_binding_; + ::onnx::GraphProto *initialization_; + ::onnx::GraphProto *algorithm_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class ModelProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.ModelProto) + */ +{ +public: + inline ModelProto() : ModelProto(nullptr) {} + ~ModelProto() override; + explicit PROTOBUF_CONSTEXPR + ModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ModelProto(const ModelProto &from); + ModelProto(ModelProto &&from) noexcept : ModelProto() { + *this = ::std::move(from); + } + + inline ModelProto &operator=(const ModelProto &from) { + CopyFrom(from); + return *this; + } + inline ModelProto &operator=(ModelProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ModelProto &default_instance() { + return *internal_default_instance(); + } + static inline const ModelProto *internal_default_instance() { + return reinterpret_cast(&_ModelProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + + friend void swap(ModelProto &a, ModelProto &b) { a.Swap(&b); } + inline void Swap(ModelProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ModelProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ModelProto *New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const ModelProto &from); + void MergeFrom(const ModelProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(ModelProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.ModelProto"; + } + +protected: + explicit ModelProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOpsetImportFieldNumber = 8, + kMetadataPropsFieldNumber = 14, + kTrainingInfoFieldNumber = 20, + kFunctionsFieldNumber = 25, + kProducerNameFieldNumber = 2, + kProducerVersionFieldNumber = 3, + kDomainFieldNumber = 4, + kDocStringFieldNumber = 6, + kGraphFieldNumber = 7, + kIrVersionFieldNumber = 1, + kModelVersionFieldNumber = 5, + }; + // repeated .onnx.OperatorSetIdProto opset_import = 8; + int opset_import_size() const; + +private: + int _internal_opset_import_size() const; + +public: + void clear_opset_import(); + ::onnx::OperatorSetIdProto *mutable_opset_import(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> * + mutable_opset_import(); + +private: + const ::onnx::OperatorSetIdProto &_internal_opset_import(int index) const; + ::onnx::OperatorSetIdProto *_internal_add_opset_import(); + +public: + const ::onnx::OperatorSetIdProto &opset_import(int index) const; + ::onnx::OperatorSetIdProto *add_opset_import(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> & + opset_import() const; + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // repeated .onnx.TrainingInfoProto training_info = 20; + int training_info_size() const; + +private: + int _internal_training_info_size() const; + +public: + void clear_training_info(); + ::onnx::TrainingInfoProto *mutable_training_info(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TrainingInfoProto> * + mutable_training_info(); + +private: + const ::onnx::TrainingInfoProto &_internal_training_info(int index) const; + ::onnx::TrainingInfoProto *_internal_add_training_info(); + +public: + const ::onnx::TrainingInfoProto &training_info(int index) const; + ::onnx::TrainingInfoProto *add_training_info(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TrainingInfoProto> & + training_info() const; + + // repeated .onnx.FunctionProto functions = 25; + int functions_size() const; + +private: + int _internal_functions_size() const; + +public: + void clear_functions(); + ::onnx::FunctionProto *mutable_functions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::FunctionProto> * + mutable_functions(); + +private: + const ::onnx::FunctionProto &_internal_functions(int index) const; + ::onnx::FunctionProto *_internal_add_functions(); + +public: + const ::onnx::FunctionProto &functions(int index) const; + ::onnx::FunctionProto *add_functions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::FunctionProto> & + functions() const; + + // optional string producer_name = 2; + bool has_producer_name() const; + +private: + bool _internal_has_producer_name() const; + +public: + void clear_producer_name(); + const std::string &producer_name() const; + template + void set_producer_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_producer_name(); + PROTOBUF_NODISCARD std::string *release_producer_name(); + void set_allocated_producer_name(std::string *producer_name); + +private: + const std::string &_internal_producer_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_producer_name(const std::string &value); + std::string *_internal_mutable_producer_name(); + +public: + // optional string producer_version = 3; + bool has_producer_version() const; + +private: + bool _internal_has_producer_version() const; + +public: + void clear_producer_version(); + const std::string &producer_version() const; + template + void set_producer_version(ArgT0 &&arg0, ArgT... args); + std::string *mutable_producer_version(); + PROTOBUF_NODISCARD std::string *release_producer_version(); + void set_allocated_producer_version(std::string *producer_version); + +private: + const std::string &_internal_producer_version() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_producer_version(const std::string &value); + std::string *_internal_mutable_producer_version(); + +public: + // optional string domain = 4; + bool has_domain() const; + +private: + bool _internal_has_domain() const; + +public: + void clear_domain(); + const std::string &domain() const; + template + void set_domain(ArgT0 &&arg0, ArgT... args); + std::string *mutable_domain(); + PROTOBUF_NODISCARD std::string *release_domain(); + void set_allocated_domain(std::string *domain); + +private: + const std::string &_internal_domain() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_domain(const std::string &value); + std::string *_internal_mutable_domain(); + +public: + // optional string doc_string = 6; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional .onnx.GraphProto graph = 7; + bool has_graph() const; + +private: + bool _internal_has_graph() const; + +public: + void clear_graph(); + const ::onnx::GraphProto &graph() const; + PROTOBUF_NODISCARD ::onnx::GraphProto *release_graph(); + ::onnx::GraphProto *mutable_graph(); + void set_allocated_graph(::onnx::GraphProto *graph); + +private: + const ::onnx::GraphProto &_internal_graph() const; + ::onnx::GraphProto *_internal_mutable_graph(); + +public: + void unsafe_arena_set_allocated_graph(::onnx::GraphProto *graph); + ::onnx::GraphProto *unsafe_arena_release_graph(); + + // optional int64 ir_version = 1; + bool has_ir_version() const; + +private: + bool _internal_has_ir_version() const; + +public: + void clear_ir_version(); + int64_t ir_version() const; + void set_ir_version(int64_t value); + +private: + int64_t _internal_ir_version() const; + void _internal_set_ir_version(int64_t value); + +public: + // optional int64 model_version = 5; + bool has_model_version() const; + +private: + bool _internal_has_model_version() const; + +public: + void clear_model_version(); + int64_t model_version() const; + void set_model_version(int64_t value); + +private: + int64_t _internal_model_version() const; + void _internal_set_model_version(int64_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.ModelProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> + opset_import_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TrainingInfoProto> + training_info_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::FunctionProto> functions_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_version_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::onnx::GraphProto *graph_; + int64_t ir_version_; + int64_t model_version_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class StringStringEntryProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.StringStringEntryProto) + */ +{ +public: + inline StringStringEntryProto() : StringStringEntryProto(nullptr) {} + ~StringStringEntryProto() override; + explicit PROTOBUF_CONSTEXPR StringStringEntryProto( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + StringStringEntryProto(const StringStringEntryProto &from); + StringStringEntryProto(StringStringEntryProto &&from) noexcept : + StringStringEntryProto() { + *this = ::std::move(from); + } + + inline StringStringEntryProto &operator=(const StringStringEntryProto &from) { + CopyFrom(from); + return *this; + } + inline StringStringEntryProto & + operator=(StringStringEntryProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const StringStringEntryProto &default_instance() { + return *internal_default_instance(); + } + static inline const StringStringEntryProto *internal_default_instance() { + return reinterpret_cast( + &_StringStringEntryProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + + friend void swap(StringStringEntryProto &a, StringStringEntryProto &b) { + a.Swap(&b); + } + inline void Swap(StringStringEntryProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(StringStringEntryProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + StringStringEntryProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const StringStringEntryProto &from); + void MergeFrom(const StringStringEntryProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(StringStringEntryProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.StringStringEntryProto"; + } + +protected: + explicit StringStringEntryProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // optional string key = 1; + bool has_key() const; + +private: + bool _internal_has_key() const; + +public: + void clear_key(); + const std::string &key() const; + template + void set_key(ArgT0 &&arg0, ArgT... args); + std::string *mutable_key(); + PROTOBUF_NODISCARD std::string *release_key(); + void set_allocated_key(std::string *key); + +private: + const std::string &_internal_key() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_key(const std::string &value); + std::string *_internal_mutable_key(); + +public: + // optional string value = 2; + bool has_value() const; + +private: + bool _internal_has_value() const; + +public: + void clear_value(); + const std::string &value() const; + template + void set_value(ArgT0 &&arg0, ArgT... args); + std::string *mutable_value(); + PROTOBUF_NODISCARD std::string *release_value(); + void set_allocated_value(std::string *value); + +private: + const std::string &_internal_value() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_value(const std::string &value); + std::string *_internal_mutable_value(); + +public: + // @@protoc_insertion_point(class_scope:onnx.StringStringEntryProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TensorAnnotation final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorAnnotation) + */ +{ +public: + inline TensorAnnotation() : TensorAnnotation(nullptr) {} + ~TensorAnnotation() override; + explicit PROTOBUF_CONSTEXPR + TensorAnnotation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TensorAnnotation(const TensorAnnotation &from); + TensorAnnotation(TensorAnnotation &&from) noexcept : TensorAnnotation() { + *this = ::std::move(from); + } + + inline TensorAnnotation &operator=(const TensorAnnotation &from) { + CopyFrom(from); + return *this; + } + inline TensorAnnotation &operator=(TensorAnnotation &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TensorAnnotation &default_instance() { + return *internal_default_instance(); + } + static inline const TensorAnnotation *internal_default_instance() { + return reinterpret_cast( + &_TensorAnnotation_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + + friend void swap(TensorAnnotation &a, TensorAnnotation &b) { a.Swap(&b); } + inline void Swap(TensorAnnotation *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TensorAnnotation *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TensorAnnotation * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TensorAnnotation &from); + void MergeFrom(const TensorAnnotation &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorAnnotation *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TensorAnnotation"; + } + +protected: + explicit TensorAnnotation(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kQuantParameterTensorNamesFieldNumber = 2, + kTensorNameFieldNumber = 1, + }; + // repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2; + int quant_parameter_tensor_names_size() const; + +private: + int _internal_quant_parameter_tensor_names_size() const; + +public: + void clear_quant_parameter_tensor_names(); + ::onnx::StringStringEntryProto * + mutable_quant_parameter_tensor_names(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_quant_parameter_tensor_names(); + +private: + const ::onnx::StringStringEntryProto & + _internal_quant_parameter_tensor_names(int index) const; + ::onnx::StringStringEntryProto *_internal_add_quant_parameter_tensor_names(); + +public: + const ::onnx::StringStringEntryProto & + quant_parameter_tensor_names(int index) const; + ::onnx::StringStringEntryProto *add_quant_parameter_tensor_names(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + quant_parameter_tensor_names() const; + + // optional string tensor_name = 1; + bool has_tensor_name() const; + +private: + bool _internal_has_tensor_name() const; + +public: + void clear_tensor_name(); + const std::string &tensor_name() const; + template + void set_tensor_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_tensor_name(); + PROTOBUF_NODISCARD std::string *release_tensor_name(); + void set_allocated_tensor_name(std::string *tensor_name); + +private: + const std::string &_internal_tensor_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_tensor_name(const std::string &value); + std::string *_internal_mutable_tensor_name(); + +public: + // @@protoc_insertion_point(class_scope:onnx.TensorAnnotation) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + quant_parameter_tensor_names_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensor_name_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class GraphProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.GraphProto) + */ +{ +public: + inline GraphProto() : GraphProto(nullptr) {} + ~GraphProto() override; + explicit PROTOBUF_CONSTEXPR + GraphProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + GraphProto(const GraphProto &from); + GraphProto(GraphProto &&from) noexcept : GraphProto() { + *this = ::std::move(from); + } + + inline GraphProto &operator=(const GraphProto &from) { + CopyFrom(from); + return *this; + } + inline GraphProto &operator=(GraphProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const GraphProto &default_instance() { + return *internal_default_instance(); + } + static inline const GraphProto *internal_default_instance() { + return reinterpret_cast(&_GraphProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + + friend void swap(GraphProto &a, GraphProto &b) { a.Swap(&b); } + inline void Swap(GraphProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GraphProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GraphProto *New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const GraphProto &from); + void MergeFrom(const GraphProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(GraphProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.GraphProto"; + } + +protected: + explicit GraphProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNodeFieldNumber = 1, + kInitializerFieldNumber = 5, + kInputFieldNumber = 11, + kOutputFieldNumber = 12, + kValueInfoFieldNumber = 13, + kQuantizationAnnotationFieldNumber = 14, + kSparseInitializerFieldNumber = 15, + kMetadataPropsFieldNumber = 16, + kNameFieldNumber = 2, + kDocStringFieldNumber = 10, + }; + // repeated .onnx.NodeProto node = 1; + int node_size() const; + +private: + int _internal_node_size() const; + +public: + void clear_node(); + ::onnx::NodeProto *mutable_node(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> *mutable_node(); + +private: + const ::onnx::NodeProto &_internal_node(int index) const; + ::onnx::NodeProto *_internal_add_node(); + +public: + const ::onnx::NodeProto &node(int index) const; + ::onnx::NodeProto *add_node(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> & + node() const; + + // repeated .onnx.TensorProto initializer = 5; + int initializer_size() const; + +private: + int _internal_initializer_size() const; + +public: + void clear_initializer(); + ::onnx::TensorProto *mutable_initializer(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> * + mutable_initializer(); + +private: + const ::onnx::TensorProto &_internal_initializer(int index) const; + ::onnx::TensorProto *_internal_add_initializer(); + +public: + const ::onnx::TensorProto &initializer(int index) const; + ::onnx::TensorProto *add_initializer(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> & + initializer() const; + + // repeated .onnx.ValueInfoProto input = 11; + int input_size() const; + +private: + int _internal_input_size() const; + +public: + void clear_input(); + ::onnx::ValueInfoProto *mutable_input(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * + mutable_input(); + +private: + const ::onnx::ValueInfoProto &_internal_input(int index) const; + ::onnx::ValueInfoProto *_internal_add_input(); + +public: + const ::onnx::ValueInfoProto &input(int index) const; + ::onnx::ValueInfoProto *add_input(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & + input() const; + + // repeated .onnx.ValueInfoProto output = 12; + int output_size() const; + +private: + int _internal_output_size() const; + +public: + void clear_output(); + ::onnx::ValueInfoProto *mutable_output(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * + mutable_output(); + +private: + const ::onnx::ValueInfoProto &_internal_output(int index) const; + ::onnx::ValueInfoProto *_internal_add_output(); + +public: + const ::onnx::ValueInfoProto &output(int index) const; + ::onnx::ValueInfoProto *add_output(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & + output() const; + + // repeated .onnx.ValueInfoProto value_info = 13; + int value_info_size() const; + +private: + int _internal_value_info_size() const; + +public: + void clear_value_info(); + ::onnx::ValueInfoProto *mutable_value_info(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * + mutable_value_info(); + +private: + const ::onnx::ValueInfoProto &_internal_value_info(int index) const; + ::onnx::ValueInfoProto *_internal_add_value_info(); + +public: + const ::onnx::ValueInfoProto &value_info(int index) const; + ::onnx::ValueInfoProto *add_value_info(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & + value_info() const; + + // repeated .onnx.TensorAnnotation quantization_annotation = 14; + int quantization_annotation_size() const; + +private: + int _internal_quantization_annotation_size() const; + +public: + void clear_quantization_annotation(); + ::onnx::TensorAnnotation *mutable_quantization_annotation(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorAnnotation> * + mutable_quantization_annotation(); + +private: + const ::onnx::TensorAnnotation & + _internal_quantization_annotation(int index) const; + ::onnx::TensorAnnotation *_internal_add_quantization_annotation(); + +public: + const ::onnx::TensorAnnotation &quantization_annotation(int index) const; + ::onnx::TensorAnnotation *add_quantization_annotation(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorAnnotation> & + quantization_annotation() const; + + // repeated .onnx.SparseTensorProto sparse_initializer = 15; + int sparse_initializer_size() const; + +private: + int _internal_sparse_initializer_size() const; + +public: + void clear_sparse_initializer(); + ::onnx::SparseTensorProto *mutable_sparse_initializer(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> * + mutable_sparse_initializer(); + +private: + const ::onnx::SparseTensorProto & + _internal_sparse_initializer(int index) const; + ::onnx::SparseTensorProto *_internal_add_sparse_initializer(); + +public: + const ::onnx::SparseTensorProto &sparse_initializer(int index) const; + ::onnx::SparseTensorProto *add_sparse_initializer(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> & + sparse_initializer() const; + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // optional string name = 2; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional string doc_string = 10; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // @@protoc_insertion_point(class_scope:onnx.GraphProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> node_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> initializer_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> input_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> output_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> value_info_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorAnnotation> + quantization_annotation_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> + sparse_initializer_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TensorProto_Segment final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto.Segment) + */ +{ +public: + inline TensorProto_Segment() : TensorProto_Segment(nullptr) {} + ~TensorProto_Segment() override; + explicit PROTOBUF_CONSTEXPR + TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TensorProto_Segment(const TensorProto_Segment &from); + TensorProto_Segment(TensorProto_Segment &&from) noexcept : + TensorProto_Segment() { + *this = ::std::move(from); + } + + inline TensorProto_Segment &operator=(const TensorProto_Segment &from) { + CopyFrom(from); + return *this; + } + inline TensorProto_Segment &operator=(TensorProto_Segment &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TensorProto_Segment &default_instance() { + return *internal_default_instance(); + } + static inline const TensorProto_Segment *internal_default_instance() { + return reinterpret_cast( + &_TensorProto_Segment_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + + friend void swap(TensorProto_Segment &a, TensorProto_Segment &b) { + a.Swap(&b); + } + inline void Swap(TensorProto_Segment *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TensorProto_Segment *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TensorProto_Segment * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TensorProto_Segment &from); + void MergeFrom(const TensorProto_Segment &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorProto_Segment *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TensorProto.Segment"; + } + +protected: + explicit TensorProto_Segment(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBeginFieldNumber = 1, + kEndFieldNumber = 2, + }; + // optional int64 begin = 1; + bool has_begin() const; + +private: + bool _internal_has_begin() const; + +public: + void clear_begin(); + int64_t begin() const; + void set_begin(int64_t value); + +private: + int64_t _internal_begin() const; + void _internal_set_begin(int64_t value); + +public: + // optional int64 end = 2; + bool has_end() const; + +private: + bool _internal_has_end() const; + +public: + void clear_end(); + int64_t end() const; + void set_end(int64_t value); + +private: + int64_t _internal_end() const; + void _internal_set_end(int64_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.TensorProto.Segment) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + int64_t begin_; + int64_t end_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TensorProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorProto) + */ +{ +public: + inline TensorProto() : TensorProto(nullptr) {} + ~TensorProto() override; + explicit PROTOBUF_CONSTEXPR + TensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TensorProto(const TensorProto &from); + TensorProto(TensorProto &&from) noexcept : TensorProto() { + *this = ::std::move(from); + } + + inline TensorProto &operator=(const TensorProto &from) { + CopyFrom(from); + return *this; + } + inline TensorProto &operator=(TensorProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TensorProto &default_instance() { + return *internal_default_instance(); + } + static inline const TensorProto *internal_default_instance() { + return reinterpret_cast( + &_TensorProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + + friend void swap(TensorProto &a, TensorProto &b) { a.Swap(&b); } + inline void Swap(TensorProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TensorProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TensorProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TensorProto &from); + void MergeFrom(const TensorProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TensorProto"; + } + +protected: + explicit TensorProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef TensorProto_Segment Segment; + + typedef TensorProto_DataType DataType; + static constexpr DataType UNDEFINED = TensorProto_DataType_UNDEFINED; + static constexpr DataType FLOAT = TensorProto_DataType_FLOAT; + static constexpr DataType UINT8 = TensorProto_DataType_UINT8; + static constexpr DataType INT8 = TensorProto_DataType_INT8; + static constexpr DataType UINT16 = TensorProto_DataType_UINT16; + static constexpr DataType INT16 = TensorProto_DataType_INT16; + static constexpr DataType INT32 = TensorProto_DataType_INT32; + static constexpr DataType INT64 = TensorProto_DataType_INT64; + static constexpr DataType STRING = TensorProto_DataType_STRING; + static constexpr DataType BOOL = TensorProto_DataType_BOOL; + static constexpr DataType FLOAT16 = TensorProto_DataType_FLOAT16; + static constexpr DataType DOUBLE = TensorProto_DataType_DOUBLE; + static constexpr DataType UINT32 = TensorProto_DataType_UINT32; + static constexpr DataType UINT64 = TensorProto_DataType_UINT64; + static constexpr DataType COMPLEX64 = TensorProto_DataType_COMPLEX64; + static constexpr DataType COMPLEX128 = TensorProto_DataType_COMPLEX128; + static constexpr DataType BFLOAT16 = TensorProto_DataType_BFLOAT16; + static constexpr DataType FLOAT8E4M3FN = TensorProto_DataType_FLOAT8E4M3FN; + static constexpr DataType FLOAT8E4M3FNUZ = + TensorProto_DataType_FLOAT8E4M3FNUZ; + static constexpr DataType FLOAT8E5M2 = TensorProto_DataType_FLOAT8E5M2; + static constexpr DataType FLOAT8E5M2FNUZ = + TensorProto_DataType_FLOAT8E5M2FNUZ; + static constexpr DataType UINT4 = TensorProto_DataType_UINT4; + static constexpr DataType INT4 = TensorProto_DataType_INT4; + static constexpr DataType FLOAT4E2M1 = TensorProto_DataType_FLOAT4E2M1; + static inline bool DataType_IsValid(int value) { + return TensorProto_DataType_IsValid(value); + } + static constexpr DataType DataType_MIN = TensorProto_DataType_DataType_MIN; + static constexpr DataType DataType_MAX = TensorProto_DataType_DataType_MAX; + static constexpr int DataType_ARRAYSIZE = + TensorProto_DataType_DataType_ARRAYSIZE; + template + static inline const std::string &DataType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataType_Name."); + return TensorProto_DataType_Name(enum_t_value); + } + static inline bool + DataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DataType *value) { + return TensorProto_DataType_Parse(name, value); + } + + typedef TensorProto_DataLocation DataLocation; + static constexpr DataLocation DEFAULT = TensorProto_DataLocation_DEFAULT; + static constexpr DataLocation EXTERNAL = TensorProto_DataLocation_EXTERNAL; + static inline bool DataLocation_IsValid(int value) { + return TensorProto_DataLocation_IsValid(value); + } + static constexpr DataLocation DataLocation_MIN = + TensorProto_DataLocation_DataLocation_MIN; + static constexpr DataLocation DataLocation_MAX = + TensorProto_DataLocation_DataLocation_MAX; + static constexpr int DataLocation_ARRAYSIZE = + TensorProto_DataLocation_DataLocation_ARRAYSIZE; + template + static inline const std::string &DataLocation_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DataLocation_Name."); + return TensorProto_DataLocation_Name(enum_t_value); + } + static inline bool + DataLocation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + DataLocation *value) { + return TensorProto_DataLocation_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kDimsFieldNumber = 1, + kFloatDataFieldNumber = 4, + kInt32DataFieldNumber = 5, + kStringDataFieldNumber = 6, + kInt64DataFieldNumber = 7, + kDoubleDataFieldNumber = 10, + kUint64DataFieldNumber = 11, + kExternalDataFieldNumber = 13, + kMetadataPropsFieldNumber = 16, + kNameFieldNumber = 8, + kRawDataFieldNumber = 9, + kDocStringFieldNumber = 12, + kSegmentFieldNumber = 3, + kDataTypeFieldNumber = 2, + kDataLocationFieldNumber = 14, + }; + // repeated int64 dims = 1; + int dims_size() const; + +private: + int _internal_dims_size() const; + +public: + void clear_dims(); + +private: + int64_t _internal_dims(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &_internal_dims() const; + void _internal_add_dims(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField *_internal_mutable_dims(); + +public: + int64_t dims(int index) const; + void set_dims(int index, int64_t value); + void add_dims(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &dims() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_dims(); + + // repeated float float_data = 4 [packed = true]; + int float_data_size() const; + +private: + int _internal_float_data_size() const; + +public: + void clear_float_data(); + +private: + float _internal_float_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField & + _internal_float_data() const; + void _internal_add_float_data(float value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField *_internal_mutable_float_data(); + +public: + float float_data(int index) const; + void set_float_data(int index, float value); + void add_float_data(float value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &float_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_float_data(); + + // repeated int32 int32_data = 5 [packed = true]; + int int32_data_size() const; + +private: + int _internal_int32_data_size() const; + +public: + void clear_int32_data(); + +private: + int32_t _internal_int32_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField & + _internal_int32_data() const; + void _internal_add_int32_data(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField * + _internal_mutable_int32_data(); + +public: + int32_t int32_data(int index) const; + void set_int32_data(int index, int32_t value); + void add_int32_data(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &int32_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_int32_data(); + + // repeated bytes string_data = 6; + int string_data_size() const; + +private: + int _internal_string_data_size() const; + +public: + void clear_string_data(); + const std::string &string_data(int index) const; + std::string *mutable_string_data(int index); + void set_string_data(int index, const std::string &value); + void set_string_data(int index, std::string &&value); + void set_string_data(int index, const char *value); + void set_string_data(int index, const void *value, size_t size); + std::string *add_string_data(); + void add_string_data(const std::string &value); + void add_string_data(std::string &&value); + void add_string_data(const char *value); + void add_string_data(const void *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & + string_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_string_data(); + +private: + const std::string &_internal_string_data(int index) const; + std::string *_internal_add_string_data(); + +public: + // repeated int64 int64_data = 7 [packed = true]; + int int64_data_size() const; + +private: + int _internal_int64_data_size() const; + +public: + void clear_int64_data(); + +private: + int64_t _internal_int64_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField & + _internal_int64_data() const; + void _internal_add_int64_data(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField * + _internal_mutable_int64_data(); + +public: + int64_t int64_data(int index) const; + void set_int64_data(int index, int64_t value); + void add_int64_data(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &int64_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_int64_data(); + + // repeated double double_data = 10 [packed = true]; + int double_data_size() const; + +private: + int _internal_double_data_size() const; + +public: + void clear_double_data(); + +private: + double _internal_double_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField & + _internal_double_data() const; + void _internal_add_double_data(double value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField * + _internal_mutable_double_data(); + +public: + double double_data(int index) const; + void set_double_data(int index, double value); + void add_double_data(double value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &double_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_double_data(); + + // repeated uint64 uint64_data = 11 [packed = true]; + int uint64_data_size() const; + +private: + int _internal_uint64_data_size() const; + +public: + void clear_uint64_data(); + +private: + uint64_t _internal_uint64_data(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField & + _internal_uint64_data() const; + void _internal_add_uint64_data(uint64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField * + _internal_mutable_uint64_data(); + +public: + uint64_t uint64_data(int index) const; + void set_uint64_data(int index, uint64_t value); + void add_uint64_data(uint64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &uint64_data() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_uint64_data(); + + // repeated .onnx.StringStringEntryProto external_data = 13; + int external_data_size() const; + +private: + int _internal_external_data_size() const; + +public: + void clear_external_data(); + ::onnx::StringStringEntryProto *mutable_external_data(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_external_data(); + +private: + const ::onnx::StringStringEntryProto & + _internal_external_data(int index) const; + ::onnx::StringStringEntryProto *_internal_add_external_data(); + +public: + const ::onnx::StringStringEntryProto &external_data(int index) const; + ::onnx::StringStringEntryProto *add_external_data(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + external_data() const; + + // repeated .onnx.StringStringEntryProto metadata_props = 16; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // optional string name = 8; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional bytes raw_data = 9; + bool has_raw_data() const; + +private: + bool _internal_has_raw_data() const; + +public: + void clear_raw_data(); + const std::string &raw_data() const; + template + void set_raw_data(ArgT0 &&arg0, ArgT... args); + std::string *mutable_raw_data(); + PROTOBUF_NODISCARD std::string *release_raw_data(); + void set_allocated_raw_data(std::string *raw_data); + +private: + const std::string &_internal_raw_data() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_raw_data(const std::string &value); + std::string *_internal_mutable_raw_data(); + +public: + // optional string doc_string = 12; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional .onnx.TensorProto.Segment segment = 3; + bool has_segment() const; + +private: + bool _internal_has_segment() const; + +public: + void clear_segment(); + const ::onnx::TensorProto_Segment &segment() const; + PROTOBUF_NODISCARD ::onnx::TensorProto_Segment *release_segment(); + ::onnx::TensorProto_Segment *mutable_segment(); + void set_allocated_segment(::onnx::TensorProto_Segment *segment); + +private: + const ::onnx::TensorProto_Segment &_internal_segment() const; + ::onnx::TensorProto_Segment *_internal_mutable_segment(); + +public: + void unsafe_arena_set_allocated_segment(::onnx::TensorProto_Segment *segment); + ::onnx::TensorProto_Segment *unsafe_arena_release_segment(); + + // optional int32 data_type = 2; + bool has_data_type() const; + +private: + bool _internal_has_data_type() const; + +public: + void clear_data_type(); + int32_t data_type() const; + void set_data_type(int32_t value); + +private: + int32_t _internal_data_type() const; + void _internal_set_data_type(int32_t value); + +public: + // optional .onnx.TensorProto.DataLocation data_location = 14; + bool has_data_location() const; + +private: + bool _internal_has_data_location() const; + +public: + void clear_data_location(); + ::onnx::TensorProto_DataLocation data_location() const; + void set_data_location(::onnx::TensorProto_DataLocation value); + +private: + ::onnx::TensorProto_DataLocation _internal_data_location() const; + void _internal_set_data_location(::onnx::TensorProto_DataLocation value); + +public: + // @@protoc_insertion_point(class_scope:onnx.TensorProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField dims_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField float_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField int32_data_; + mutable std::atomic _int32_data_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField string_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField int64_data_; + mutable std::atomic _int64_data_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField double_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField uint64_data_; + mutable std::atomic _uint64_data_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + external_data_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::onnx::TensorProto_Segment *segment_; + int32_t data_type_; + int data_location_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class SparseTensorProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.SparseTensorProto) + */ +{ +public: + inline SparseTensorProto() : SparseTensorProto(nullptr) {} + ~SparseTensorProto() override; + explicit PROTOBUF_CONSTEXPR + SparseTensorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SparseTensorProto(const SparseTensorProto &from); + SparseTensorProto(SparseTensorProto &&from) noexcept : SparseTensorProto() { + *this = ::std::move(from); + } + + inline SparseTensorProto &operator=(const SparseTensorProto &from) { + CopyFrom(from); + return *this; + } + inline SparseTensorProto &operator=(SparseTensorProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SparseTensorProto &default_instance() { + return *internal_default_instance(); + } + static inline const SparseTensorProto *internal_default_instance() { + return reinterpret_cast( + &_SparseTensorProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 10; + + friend void swap(SparseTensorProto &a, SparseTensorProto &b) { a.Swap(&b); } + inline void Swap(SparseTensorProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SparseTensorProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SparseTensorProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const SparseTensorProto &from); + void MergeFrom(const SparseTensorProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(SparseTensorProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.SparseTensorProto"; + } + +protected: + explicit SparseTensorProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDimsFieldNumber = 3, + kValuesFieldNumber = 1, + kIndicesFieldNumber = 2, + }; + // repeated int64 dims = 3; + int dims_size() const; + +private: + int _internal_dims_size() const; + +public: + void clear_dims(); + +private: + int64_t _internal_dims(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &_internal_dims() const; + void _internal_add_dims(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField *_internal_mutable_dims(); + +public: + int64_t dims(int index) const; + void set_dims(int index, int64_t value); + void add_dims(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField &dims() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField *mutable_dims(); + + // optional .onnx.TensorProto values = 1; + bool has_values() const; + +private: + bool _internal_has_values() const; + +public: + void clear_values(); + const ::onnx::TensorProto &values() const; + PROTOBUF_NODISCARD ::onnx::TensorProto *release_values(); + ::onnx::TensorProto *mutable_values(); + void set_allocated_values(::onnx::TensorProto *values); + +private: + const ::onnx::TensorProto &_internal_values() const; + ::onnx::TensorProto *_internal_mutable_values(); + +public: + void unsafe_arena_set_allocated_values(::onnx::TensorProto *values); + ::onnx::TensorProto *unsafe_arena_release_values(); + + // optional .onnx.TensorProto indices = 2; + bool has_indices() const; + +private: + bool _internal_has_indices() const; + +public: + void clear_indices(); + const ::onnx::TensorProto &indices() const; + PROTOBUF_NODISCARD ::onnx::TensorProto *release_indices(); + ::onnx::TensorProto *mutable_indices(); + void set_allocated_indices(::onnx::TensorProto *indices); + +private: + const ::onnx::TensorProto &_internal_indices() const; + ::onnx::TensorProto *_internal_mutable_indices(); + +public: + void unsafe_arena_set_allocated_indices(::onnx::TensorProto *indices); + ::onnx::TensorProto *unsafe_arena_release_indices(); + + // @@protoc_insertion_point(class_scope:onnx.SparseTensorProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField dims_; + ::onnx::TensorProto *values_; + ::onnx::TensorProto *indices_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TensorShapeProto_Dimension final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto.Dimension) + */ +{ +public: + inline TensorShapeProto_Dimension() : TensorShapeProto_Dimension(nullptr) {} + ~TensorShapeProto_Dimension() override; + explicit PROTOBUF_CONSTEXPR TensorShapeProto_Dimension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TensorShapeProto_Dimension(const TensorShapeProto_Dimension &from); + TensorShapeProto_Dimension(TensorShapeProto_Dimension &&from) noexcept : + TensorShapeProto_Dimension() { + *this = ::std::move(from); + } + + inline TensorShapeProto_Dimension & + operator=(const TensorShapeProto_Dimension &from) { + CopyFrom(from); + return *this; + } + inline TensorShapeProto_Dimension & + operator=(TensorShapeProto_Dimension &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TensorShapeProto_Dimension &default_instance() { + return *internal_default_instance(); + } + enum ValueCase { + kDimValue = 1, + kDimParam = 2, + VALUE_NOT_SET = 0, + }; + + static inline const TensorShapeProto_Dimension *internal_default_instance() { + return reinterpret_cast( + &_TensorShapeProto_Dimension_default_instance_); + } + static constexpr int kIndexInFileMessages = 11; + + friend void swap(TensorShapeProto_Dimension &a, + TensorShapeProto_Dimension &b) { + a.Swap(&b); + } + inline void Swap(TensorShapeProto_Dimension *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TensorShapeProto_Dimension *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TensorShapeProto_Dimension * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TensorShapeProto_Dimension &from); + void MergeFrom(const TensorShapeProto_Dimension &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorShapeProto_Dimension *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TensorShapeProto.Dimension"; + } + +protected: + explicit TensorShapeProto_Dimension(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDenotationFieldNumber = 3, + kDimValueFieldNumber = 1, + kDimParamFieldNumber = 2, + }; + // optional string denotation = 3; + bool has_denotation() const; + +private: + bool _internal_has_denotation() const; + +public: + void clear_denotation(); + const std::string &denotation() const; + template + void set_denotation(ArgT0 &&arg0, ArgT... args); + std::string *mutable_denotation(); + PROTOBUF_NODISCARD std::string *release_denotation(); + void set_allocated_denotation(std::string *denotation); + +private: + const std::string &_internal_denotation() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_denotation(const std::string &value); + std::string *_internal_mutable_denotation(); + +public: + // int64 dim_value = 1; + bool has_dim_value() const; + +private: + bool _internal_has_dim_value() const; + +public: + void clear_dim_value(); + int64_t dim_value() const; + void set_dim_value(int64_t value); + +private: + int64_t _internal_dim_value() const; + void _internal_set_dim_value(int64_t value); + +public: + // string dim_param = 2; + bool has_dim_param() const; + +private: + bool _internal_has_dim_param() const; + +public: + void clear_dim_param(); + const std::string &dim_param() const; + template + void set_dim_param(ArgT0 &&arg0, ArgT... args); + std::string *mutable_dim_param(); + PROTOBUF_NODISCARD std::string *release_dim_param(); + void set_allocated_dim_param(std::string *dim_param); + +private: + const std::string &_internal_dim_param() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_dim_param(const std::string &value); + std::string *_internal_mutable_dim_param(); + +public: + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto.Dimension) +private: + class _Internal; + void set_has_dim_value(); + void set_has_dim_param(); + + inline bool has_value() const; + inline void clear_has_value(); + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_; + union ValueUnion { + constexpr ValueUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + int64_t dim_value_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dim_param_; + } value_; + uint32_t _oneof_case_[1]; + + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TensorShapeProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TensorShapeProto) + */ +{ +public: + inline TensorShapeProto() : TensorShapeProto(nullptr) {} + ~TensorShapeProto() override; + explicit PROTOBUF_CONSTEXPR + TensorShapeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TensorShapeProto(const TensorShapeProto &from); + TensorShapeProto(TensorShapeProto &&from) noexcept : TensorShapeProto() { + *this = ::std::move(from); + } + + inline TensorShapeProto &operator=(const TensorShapeProto &from) { + CopyFrom(from); + return *this; + } + inline TensorShapeProto &operator=(TensorShapeProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TensorShapeProto &default_instance() { + return *internal_default_instance(); + } + static inline const TensorShapeProto *internal_default_instance() { + return reinterpret_cast( + &_TensorShapeProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 12; + + friend void swap(TensorShapeProto &a, TensorShapeProto &b) { a.Swap(&b); } + inline void Swap(TensorShapeProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TensorShapeProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TensorShapeProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TensorShapeProto &from); + void MergeFrom(const TensorShapeProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TensorShapeProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TensorShapeProto"; + } + +protected: + explicit TensorShapeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef TensorShapeProto_Dimension Dimension; + + // accessors ------------------------------------------------------- + + enum : int { + kDimFieldNumber = 1, + }; + // repeated .onnx.TensorShapeProto.Dimension dim = 1; + int dim_size() const; + +private: + int _internal_dim_size() const; + +public: + void clear_dim(); + ::onnx::TensorShapeProto_Dimension *mutable_dim(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorShapeProto_Dimension> + *mutable_dim(); + +private: + const ::onnx::TensorShapeProto_Dimension &_internal_dim(int index) const; + ::onnx::TensorShapeProto_Dimension *_internal_add_dim(); + +public: + const ::onnx::TensorShapeProto_Dimension &dim(int index) const; + ::onnx::TensorShapeProto_Dimension *add_dim(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::TensorShapeProto_Dimension> & + dim() const; + + // @@protoc_insertion_point(class_scope:onnx.TensorShapeProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorShapeProto_Dimension> + dim_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto_Tensor final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Tensor) + */ +{ +public: + inline TypeProto_Tensor() : TypeProto_Tensor(nullptr) {} + ~TypeProto_Tensor() override; + explicit PROTOBUF_CONSTEXPR + TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto_Tensor(const TypeProto_Tensor &from); + TypeProto_Tensor(TypeProto_Tensor &&from) noexcept : TypeProto_Tensor() { + *this = ::std::move(from); + } + + inline TypeProto_Tensor &operator=(const TypeProto_Tensor &from) { + CopyFrom(from); + return *this; + } + inline TypeProto_Tensor &operator=(TypeProto_Tensor &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto_Tensor &default_instance() { + return *internal_default_instance(); + } + static inline const TypeProto_Tensor *internal_default_instance() { + return reinterpret_cast( + &_TypeProto_Tensor_default_instance_); + } + static constexpr int kIndexInFileMessages = 13; + + friend void swap(TypeProto_Tensor &a, TypeProto_Tensor &b) { a.Swap(&b); } + inline void Swap(TypeProto_Tensor *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto_Tensor *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto_Tensor * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto_Tensor &from); + void MergeFrom(const TypeProto_Tensor &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto_Tensor *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto.Tensor"; + } + +protected: + explicit TypeProto_Tensor(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShapeFieldNumber = 2, + kElemTypeFieldNumber = 1, + }; + // optional .onnx.TensorShapeProto shape = 2; + bool has_shape() const; + +private: + bool _internal_has_shape() const; + +public: + void clear_shape(); + const ::onnx::TensorShapeProto &shape() const; + PROTOBUF_NODISCARD ::onnx::TensorShapeProto *release_shape(); + ::onnx::TensorShapeProto *mutable_shape(); + void set_allocated_shape(::onnx::TensorShapeProto *shape); + +private: + const ::onnx::TensorShapeProto &_internal_shape() const; + ::onnx::TensorShapeProto *_internal_mutable_shape(); + +public: + void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto *shape); + ::onnx::TensorShapeProto *unsafe_arena_release_shape(); + + // optional int32 elem_type = 1; + bool has_elem_type() const; + +private: + bool _internal_has_elem_type() const; + +public: + void clear_elem_type(); + int32_t elem_type() const; + void set_elem_type(int32_t value); + +private: + int32_t _internal_elem_type() const; + void _internal_set_elem_type(int32_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.TypeProto.Tensor) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::onnx::TensorShapeProto *shape_; + int32_t elem_type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto_Sequence final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Sequence) + */ +{ +public: + inline TypeProto_Sequence() : TypeProto_Sequence(nullptr) {} + ~TypeProto_Sequence() override; + explicit PROTOBUF_CONSTEXPR + TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto_Sequence(const TypeProto_Sequence &from); + TypeProto_Sequence(TypeProto_Sequence &&from) noexcept : + TypeProto_Sequence() { + *this = ::std::move(from); + } + + inline TypeProto_Sequence &operator=(const TypeProto_Sequence &from) { + CopyFrom(from); + return *this; + } + inline TypeProto_Sequence &operator=(TypeProto_Sequence &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto_Sequence &default_instance() { + return *internal_default_instance(); + } + static inline const TypeProto_Sequence *internal_default_instance() { + return reinterpret_cast( + &_TypeProto_Sequence_default_instance_); + } + static constexpr int kIndexInFileMessages = 14; + + friend void swap(TypeProto_Sequence &a, TypeProto_Sequence &b) { a.Swap(&b); } + inline void Swap(TypeProto_Sequence *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto_Sequence *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto_Sequence * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto_Sequence &from); + void MergeFrom(const TypeProto_Sequence &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto_Sequence *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto.Sequence"; + } + +protected: + explicit TypeProto_Sequence(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kElemTypeFieldNumber = 1, + }; + // optional .onnx.TypeProto elem_type = 1; + bool has_elem_type() const; + +private: + bool _internal_has_elem_type() const; + +public: + void clear_elem_type(); + const ::onnx::TypeProto &elem_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto *release_elem_type(); + ::onnx::TypeProto *mutable_elem_type(); + void set_allocated_elem_type(::onnx::TypeProto *elem_type); + +private: + const ::onnx::TypeProto &_internal_elem_type() const; + ::onnx::TypeProto *_internal_mutable_elem_type(); + +public: + void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto *elem_type); + ::onnx::TypeProto *unsafe_arena_release_elem_type(); + + // @@protoc_insertion_point(class_scope:onnx.TypeProto.Sequence) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::onnx::TypeProto *elem_type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto_Map final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Map) + */ +{ +public: + inline TypeProto_Map() : TypeProto_Map(nullptr) {} + ~TypeProto_Map() override; + explicit PROTOBUF_CONSTEXPR + TypeProto_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto_Map(const TypeProto_Map &from); + TypeProto_Map(TypeProto_Map &&from) noexcept : TypeProto_Map() { + *this = ::std::move(from); + } + + inline TypeProto_Map &operator=(const TypeProto_Map &from) { + CopyFrom(from); + return *this; + } + inline TypeProto_Map &operator=(TypeProto_Map &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto_Map &default_instance() { + return *internal_default_instance(); + } + static inline const TypeProto_Map *internal_default_instance() { + return reinterpret_cast( + &_TypeProto_Map_default_instance_); + } + static constexpr int kIndexInFileMessages = 15; + + friend void swap(TypeProto_Map &a, TypeProto_Map &b) { a.Swap(&b); } + inline void Swap(TypeProto_Map *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto_Map *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto_Map * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto_Map &from); + void MergeFrom(const TypeProto_Map &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto_Map *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto.Map"; + } + +protected: + explicit TypeProto_Map(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValueTypeFieldNumber = 2, + kKeyTypeFieldNumber = 1, + }; + // optional .onnx.TypeProto value_type = 2; + bool has_value_type() const; + +private: + bool _internal_has_value_type() const; + +public: + void clear_value_type(); + const ::onnx::TypeProto &value_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto *release_value_type(); + ::onnx::TypeProto *mutable_value_type(); + void set_allocated_value_type(::onnx::TypeProto *value_type); + +private: + const ::onnx::TypeProto &_internal_value_type() const; + ::onnx::TypeProto *_internal_mutable_value_type(); + +public: + void unsafe_arena_set_allocated_value_type(::onnx::TypeProto *value_type); + ::onnx::TypeProto *unsafe_arena_release_value_type(); + + // optional int32 key_type = 1; + bool has_key_type() const; + +private: + bool _internal_has_key_type() const; + +public: + void clear_key_type(); + int32_t key_type() const; + void set_key_type(int32_t value); + +private: + int32_t _internal_key_type() const; + void _internal_set_key_type(int32_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.TypeProto.Map) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::onnx::TypeProto *value_type_; + int32_t key_type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto_Optional final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.Optional) + */ +{ +public: + inline TypeProto_Optional() : TypeProto_Optional(nullptr) {} + ~TypeProto_Optional() override; + explicit PROTOBUF_CONSTEXPR + TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto_Optional(const TypeProto_Optional &from); + TypeProto_Optional(TypeProto_Optional &&from) noexcept : + TypeProto_Optional() { + *this = ::std::move(from); + } + + inline TypeProto_Optional &operator=(const TypeProto_Optional &from) { + CopyFrom(from); + return *this; + } + inline TypeProto_Optional &operator=(TypeProto_Optional &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto_Optional &default_instance() { + return *internal_default_instance(); + } + static inline const TypeProto_Optional *internal_default_instance() { + return reinterpret_cast( + &_TypeProto_Optional_default_instance_); + } + static constexpr int kIndexInFileMessages = 16; + + friend void swap(TypeProto_Optional &a, TypeProto_Optional &b) { a.Swap(&b); } + inline void Swap(TypeProto_Optional *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto_Optional *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto_Optional * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto_Optional &from); + void MergeFrom(const TypeProto_Optional &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto_Optional *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto.Optional"; + } + +protected: + explicit TypeProto_Optional(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kElemTypeFieldNumber = 1, + }; + // optional .onnx.TypeProto elem_type = 1; + bool has_elem_type() const; + +private: + bool _internal_has_elem_type() const; + +public: + void clear_elem_type(); + const ::onnx::TypeProto &elem_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto *release_elem_type(); + ::onnx::TypeProto *mutable_elem_type(); + void set_allocated_elem_type(::onnx::TypeProto *elem_type); + +private: + const ::onnx::TypeProto &_internal_elem_type() const; + ::onnx::TypeProto *_internal_mutable_elem_type(); + +public: + void unsafe_arena_set_allocated_elem_type(::onnx::TypeProto *elem_type); + ::onnx::TypeProto *unsafe_arena_release_elem_type(); + + // @@protoc_insertion_point(class_scope:onnx.TypeProto.Optional) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::onnx::TypeProto *elem_type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto_SparseTensor final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto.SparseTensor) + */ +{ +public: + inline TypeProto_SparseTensor() : TypeProto_SparseTensor(nullptr) {} + ~TypeProto_SparseTensor() override; + explicit PROTOBUF_CONSTEXPR TypeProto_SparseTensor( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto_SparseTensor(const TypeProto_SparseTensor &from); + TypeProto_SparseTensor(TypeProto_SparseTensor &&from) noexcept : + TypeProto_SparseTensor() { + *this = ::std::move(from); + } + + inline TypeProto_SparseTensor &operator=(const TypeProto_SparseTensor &from) { + CopyFrom(from); + return *this; + } + inline TypeProto_SparseTensor & + operator=(TypeProto_SparseTensor &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto_SparseTensor &default_instance() { + return *internal_default_instance(); + } + static inline const TypeProto_SparseTensor *internal_default_instance() { + return reinterpret_cast( + &_TypeProto_SparseTensor_default_instance_); + } + static constexpr int kIndexInFileMessages = 17; + + friend void swap(TypeProto_SparseTensor &a, TypeProto_SparseTensor &b) { + a.Swap(&b); + } + inline void Swap(TypeProto_SparseTensor *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto_SparseTensor *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto_SparseTensor * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto_SparseTensor &from); + void MergeFrom(const TypeProto_SparseTensor &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto_SparseTensor *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto.SparseTensor"; + } + +protected: + explicit TypeProto_SparseTensor(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kShapeFieldNumber = 2, + kElemTypeFieldNumber = 1, + }; + // optional .onnx.TensorShapeProto shape = 2; + bool has_shape() const; + +private: + bool _internal_has_shape() const; + +public: + void clear_shape(); + const ::onnx::TensorShapeProto &shape() const; + PROTOBUF_NODISCARD ::onnx::TensorShapeProto *release_shape(); + ::onnx::TensorShapeProto *mutable_shape(); + void set_allocated_shape(::onnx::TensorShapeProto *shape); + +private: + const ::onnx::TensorShapeProto &_internal_shape() const; + ::onnx::TensorShapeProto *_internal_mutable_shape(); + +public: + void unsafe_arena_set_allocated_shape(::onnx::TensorShapeProto *shape); + ::onnx::TensorShapeProto *unsafe_arena_release_shape(); + + // optional int32 elem_type = 1; + bool has_elem_type() const; + +private: + bool _internal_has_elem_type() const; + +public: + void clear_elem_type(); + int32_t elem_type() const; + void set_elem_type(int32_t value); + +private: + int32_t _internal_elem_type() const; + void _internal_set_elem_type(int32_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.TypeProto.SparseTensor) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::onnx::TensorShapeProto *shape_; + int32_t elem_type_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class TypeProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.TypeProto) + */ +{ +public: + inline TypeProto() : TypeProto(nullptr) {} + ~TypeProto() override; + explicit PROTOBUF_CONSTEXPR + TypeProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + TypeProto(const TypeProto &from); + TypeProto(TypeProto &&from) noexcept : TypeProto() { + *this = ::std::move(from); + } + + inline TypeProto &operator=(const TypeProto &from) { + CopyFrom(from); + return *this; + } + inline TypeProto &operator=(TypeProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TypeProto &default_instance() { + return *internal_default_instance(); + } + enum ValueCase { + kTensorType = 1, + kSequenceType = 4, + kMapType = 5, + kOptionalType = 9, + kSparseTensorType = 8, + VALUE_NOT_SET = 0, + }; + + static inline const TypeProto *internal_default_instance() { + return reinterpret_cast(&_TypeProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 18; + + friend void swap(TypeProto &a, TypeProto &b) { a.Swap(&b); } + inline void Swap(TypeProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TypeProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TypeProto *New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const TypeProto &from); + void MergeFrom(const TypeProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(TypeProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.TypeProto"; + } + +protected: + explicit TypeProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + typedef TypeProto_Tensor Tensor; + typedef TypeProto_Sequence Sequence; + typedef TypeProto_Map Map; + typedef TypeProto_Optional Optional; + typedef TypeProto_SparseTensor SparseTensor; + + // accessors ------------------------------------------------------- + + enum : int { + kDenotationFieldNumber = 6, + kTensorTypeFieldNumber = 1, + kSequenceTypeFieldNumber = 4, + kMapTypeFieldNumber = 5, + kOptionalTypeFieldNumber = 9, + kSparseTensorTypeFieldNumber = 8, + }; + // optional string denotation = 6; + bool has_denotation() const; + +private: + bool _internal_has_denotation() const; + +public: + void clear_denotation(); + const std::string &denotation() const; + template + void set_denotation(ArgT0 &&arg0, ArgT... args); + std::string *mutable_denotation(); + PROTOBUF_NODISCARD std::string *release_denotation(); + void set_allocated_denotation(std::string *denotation); + +private: + const std::string &_internal_denotation() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_denotation(const std::string &value); + std::string *_internal_mutable_denotation(); + +public: + // .onnx.TypeProto.Tensor tensor_type = 1; + bool has_tensor_type() const; + +private: + bool _internal_has_tensor_type() const; + +public: + void clear_tensor_type(); + const ::onnx::TypeProto_Tensor &tensor_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto_Tensor *release_tensor_type(); + ::onnx::TypeProto_Tensor *mutable_tensor_type(); + void set_allocated_tensor_type(::onnx::TypeProto_Tensor *tensor_type); + +private: + const ::onnx::TypeProto_Tensor &_internal_tensor_type() const; + ::onnx::TypeProto_Tensor *_internal_mutable_tensor_type(); + +public: + void + unsafe_arena_set_allocated_tensor_type(::onnx::TypeProto_Tensor *tensor_type); + ::onnx::TypeProto_Tensor *unsafe_arena_release_tensor_type(); + + // .onnx.TypeProto.Sequence sequence_type = 4; + bool has_sequence_type() const; + +private: + bool _internal_has_sequence_type() const; + +public: + void clear_sequence_type(); + const ::onnx::TypeProto_Sequence &sequence_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto_Sequence *release_sequence_type(); + ::onnx::TypeProto_Sequence *mutable_sequence_type(); + void set_allocated_sequence_type(::onnx::TypeProto_Sequence *sequence_type); + +private: + const ::onnx::TypeProto_Sequence &_internal_sequence_type() const; + ::onnx::TypeProto_Sequence *_internal_mutable_sequence_type(); + +public: + void unsafe_arena_set_allocated_sequence_type( + ::onnx::TypeProto_Sequence *sequence_type); + ::onnx::TypeProto_Sequence *unsafe_arena_release_sequence_type(); + + // .onnx.TypeProto.Map map_type = 5; + bool has_map_type() const; + +private: + bool _internal_has_map_type() const; + +public: + void clear_map_type(); + const ::onnx::TypeProto_Map &map_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto_Map *release_map_type(); + ::onnx::TypeProto_Map *mutable_map_type(); + void set_allocated_map_type(::onnx::TypeProto_Map *map_type); + +private: + const ::onnx::TypeProto_Map &_internal_map_type() const; + ::onnx::TypeProto_Map *_internal_mutable_map_type(); + +public: + void unsafe_arena_set_allocated_map_type(::onnx::TypeProto_Map *map_type); + ::onnx::TypeProto_Map *unsafe_arena_release_map_type(); + + // .onnx.TypeProto.Optional optional_type = 9; + bool has_optional_type() const; + +private: + bool _internal_has_optional_type() const; + +public: + void clear_optional_type(); + const ::onnx::TypeProto_Optional &optional_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto_Optional *release_optional_type(); + ::onnx::TypeProto_Optional *mutable_optional_type(); + void set_allocated_optional_type(::onnx::TypeProto_Optional *optional_type); + +private: + const ::onnx::TypeProto_Optional &_internal_optional_type() const; + ::onnx::TypeProto_Optional *_internal_mutable_optional_type(); + +public: + void unsafe_arena_set_allocated_optional_type( + ::onnx::TypeProto_Optional *optional_type); + ::onnx::TypeProto_Optional *unsafe_arena_release_optional_type(); + + // .onnx.TypeProto.SparseTensor sparse_tensor_type = 8; + bool has_sparse_tensor_type() const; + +private: + bool _internal_has_sparse_tensor_type() const; + +public: + void clear_sparse_tensor_type(); + const ::onnx::TypeProto_SparseTensor &sparse_tensor_type() const; + PROTOBUF_NODISCARD ::onnx::TypeProto_SparseTensor * + release_sparse_tensor_type(); + ::onnx::TypeProto_SparseTensor *mutable_sparse_tensor_type(); + void set_allocated_sparse_tensor_type( + ::onnx::TypeProto_SparseTensor *sparse_tensor_type); + +private: + const ::onnx::TypeProto_SparseTensor &_internal_sparse_tensor_type() const; + ::onnx::TypeProto_SparseTensor *_internal_mutable_sparse_tensor_type(); + +public: + void unsafe_arena_set_allocated_sparse_tensor_type( + ::onnx::TypeProto_SparseTensor *sparse_tensor_type); + ::onnx::TypeProto_SparseTensor *unsafe_arena_release_sparse_tensor_type(); + + void clear_value(); + ValueCase value_case() const; + // @@protoc_insertion_point(class_scope:onnx.TypeProto) +private: + class _Internal; + void set_has_tensor_type(); + void set_has_sequence_type(); + void set_has_map_type(); + void set_has_optional_type(); + void set_has_sparse_tensor_type(); + + inline bool has_value() const; + inline void clear_has_value(); + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr denotation_; + union ValueUnion { + constexpr ValueUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::onnx::TypeProto_Tensor *tensor_type_; + ::onnx::TypeProto_Sequence *sequence_type_; + ::onnx::TypeProto_Map *map_type_; + ::onnx::TypeProto_Optional *optional_type_; + ::onnx::TypeProto_SparseTensor *sparse_tensor_type_; + } value_; + uint32_t _oneof_case_[1]; + + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class OperatorSetIdProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.OperatorSetIdProto) + */ +{ +public: + inline OperatorSetIdProto() : OperatorSetIdProto(nullptr) {} + ~OperatorSetIdProto() override; + explicit PROTOBUF_CONSTEXPR + OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + OperatorSetIdProto(const OperatorSetIdProto &from); + OperatorSetIdProto(OperatorSetIdProto &&from) noexcept : + OperatorSetIdProto() { + *this = ::std::move(from); + } + + inline OperatorSetIdProto &operator=(const OperatorSetIdProto &from) { + CopyFrom(from); + return *this; + } + inline OperatorSetIdProto &operator=(OperatorSetIdProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const OperatorSetIdProto &default_instance() { + return *internal_default_instance(); + } + static inline const OperatorSetIdProto *internal_default_instance() { + return reinterpret_cast( + &_OperatorSetIdProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 19; + + friend void swap(OperatorSetIdProto &a, OperatorSetIdProto &b) { a.Swap(&b); } + inline void Swap(OperatorSetIdProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(OperatorSetIdProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + OperatorSetIdProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const OperatorSetIdProto &from); + void MergeFrom(const OperatorSetIdProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(OperatorSetIdProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.OperatorSetIdProto"; + } + +protected: + explicit OperatorSetIdProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDomainFieldNumber = 1, + kVersionFieldNumber = 2, + }; + // optional string domain = 1; + bool has_domain() const; + +private: + bool _internal_has_domain() const; + +public: + void clear_domain(); + const std::string &domain() const; + template + void set_domain(ArgT0 &&arg0, ArgT... args); + std::string *mutable_domain(); + PROTOBUF_NODISCARD std::string *release_domain(); + void set_allocated_domain(std::string *domain); + +private: + const std::string &_internal_domain() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_domain(const std::string &value); + std::string *_internal_mutable_domain(); + +public: + // optional int64 version = 2; + bool has_version() const; + +private: + bool _internal_has_version() const; + +public: + void clear_version(); + int64_t version() const; + void set_version(int64_t value); + +private: + int64_t _internal_version() const; + void _internal_set_version(int64_t value); + +public: + // @@protoc_insertion_point(class_scope:onnx.OperatorSetIdProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; + int64_t version_; + friend struct ::TableStruct_onnx_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionProto final + : public ::PROTOBUF_NAMESPACE_ID:: + MessageLite /* @@protoc_insertion_point(class_definition:onnx.FunctionProto) + */ +{ +public: + inline FunctionProto() : FunctionProto(nullptr) {} + ~FunctionProto() override; + explicit PROTOBUF_CONSTEXPR + FunctionProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionProto(const FunctionProto &from); + FunctionProto(FunctionProto &&from) noexcept : FunctionProto() { + *this = ::std::move(from); + } + + inline FunctionProto &operator=(const FunctionProto &from) { + CopyFrom(from); + return *this; + } + inline FunctionProto &operator=(FunctionProto &&from) noexcept { + if (this == &from) + return *this; + if (GetOwningArena() == from.GetOwningArena() +#ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr +#endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string &unknown_fields() const { + return _internal_metadata_.unknown_fields( + ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString); + } + inline std::string *mutable_unknown_fields() { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const FunctionProto &default_instance() { + return *internal_default_instance(); + } + static inline const FunctionProto *internal_default_instance() { + return reinterpret_cast( + &_FunctionProto_default_instance_); + } + static constexpr int kIndexInFileMessages = 20; + + friend void swap(FunctionProto &a, FunctionProto &b) { a.Swap(&b); } + inline void Swap(FunctionProto *other) { + if (other == this) + return; +#ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { +#else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { +#endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionProto *other) { + if (other == this) + return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FunctionProto * + New(::PROTOBUF_NAMESPACE_ID::Arena *arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + void + CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite &from) final; + void CopyFrom(const FunctionProto &from); + void MergeFrom(const FunctionProto &from); + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char * + _InternalParse(const char *ptr, + ::PROTOBUF_NAMESPACE_ID::internal::ParseContext *ctx) final; + uint8_t *_InternalSerialize( + uint8_t *target, + ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream *stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + +private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + void InternalSwap(FunctionProto *other); + +private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "onnx.FunctionProto"; + } + +protected: + explicit FunctionProto(::PROTOBUF_NAMESPACE_ID::Arena *arena, + bool is_message_owned = false); + +public: + std::string GetTypeName() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInputFieldNumber = 4, + kOutputFieldNumber = 5, + kAttributeFieldNumber = 6, + kNodeFieldNumber = 7, + kOpsetImportFieldNumber = 9, + kAttributeProtoFieldNumber = 11, + kValueInfoFieldNumber = 12, + kMetadataPropsFieldNumber = 14, + kNameFieldNumber = 1, + kDocStringFieldNumber = 8, + kDomainFieldNumber = 10, + kOverloadFieldNumber = 13, + }; + // repeated string input = 4; + int input_size() const; + +private: + int _internal_input_size() const; + +public: + void clear_input(); + const std::string &input(int index) const; + std::string *mutable_input(int index); + void set_input(int index, const std::string &value); + void set_input(int index, std::string &&value); + void set_input(int index, const char *value); + void set_input(int index, const char *value, size_t size); + std::string *add_input(); + void add_input(const std::string &value); + void add_input(std::string &&value); + void add_input(const char *value); + void add_input(const char *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField &input() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_input(); + +private: + const std::string &_internal_input(int index) const; + std::string *_internal_add_input(); + +public: + // repeated string output = 5; + int output_size() const; + +private: + int _internal_output_size() const; + +public: + void clear_output(); + const std::string &output(int index) const; + std::string *mutable_output(int index); + void set_output(int index, const std::string &value); + void set_output(int index, std::string &&value); + void set_output(int index, const char *value); + void set_output(int index, const char *value, size_t size); + std::string *add_output(); + void add_output(const std::string &value); + void add_output(std::string &&value); + void add_output(const char *value); + void add_output(const char *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField &output() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_output(); + +private: + const std::string &_internal_output(int index) const; + std::string *_internal_add_output(); + +public: + // repeated string attribute = 6; + int attribute_size() const; + +private: + int _internal_attribute_size() const; + +public: + void clear_attribute(); + const std::string &attribute(int index) const; + std::string *mutable_attribute(int index); + void set_attribute(int index, const std::string &value); + void set_attribute(int index, std::string &&value); + void set_attribute(int index, const char *value); + void set_attribute(int index, const char *value, size_t size); + std::string *add_attribute(); + void add_attribute(const std::string &value); + void add_attribute(std::string &&value); + void add_attribute(const char *value); + void add_attribute(const char *value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & + attribute() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField *mutable_attribute(); + +private: + const std::string &_internal_attribute(int index) const; + std::string *_internal_add_attribute(); + +public: + // repeated .onnx.NodeProto node = 7; + int node_size() const; + +private: + int _internal_node_size() const; + +public: + void clear_node(); + ::onnx::NodeProto *mutable_node(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> *mutable_node(); + +private: + const ::onnx::NodeProto &_internal_node(int index) const; + ::onnx::NodeProto *_internal_add_node(); + +public: + const ::onnx::NodeProto &node(int index) const; + ::onnx::NodeProto *add_node(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> & + node() const; + + // repeated .onnx.OperatorSetIdProto opset_import = 9; + int opset_import_size() const; + +private: + int _internal_opset_import_size() const; + +public: + void clear_opset_import(); + ::onnx::OperatorSetIdProto *mutable_opset_import(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> * + mutable_opset_import(); + +private: + const ::onnx::OperatorSetIdProto &_internal_opset_import(int index) const; + ::onnx::OperatorSetIdProto *_internal_add_opset_import(); + +public: + const ::onnx::OperatorSetIdProto &opset_import(int index) const; + ::onnx::OperatorSetIdProto *add_opset_import(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> & + opset_import() const; + + // repeated .onnx.AttributeProto attribute_proto = 11; + int attribute_proto_size() const; + +private: + int _internal_attribute_proto_size() const; + +public: + void clear_attribute_proto(); + ::onnx::AttributeProto *mutable_attribute_proto(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> * + mutable_attribute_proto(); + +private: + const ::onnx::AttributeProto &_internal_attribute_proto(int index) const; + ::onnx::AttributeProto *_internal_add_attribute_proto(); + +public: + const ::onnx::AttributeProto &attribute_proto(int index) const; + ::onnx::AttributeProto *add_attribute_proto(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> & + attribute_proto() const; + + // repeated .onnx.ValueInfoProto value_info = 12; + int value_info_size() const; + +private: + int _internal_value_info_size() const; + +public: + void clear_value_info(); + ::onnx::ValueInfoProto *mutable_value_info(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * + mutable_value_info(); + +private: + const ::onnx::ValueInfoProto &_internal_value_info(int index) const; + ::onnx::ValueInfoProto *_internal_add_value_info(); + +public: + const ::onnx::ValueInfoProto &value_info(int index) const; + ::onnx::ValueInfoProto *add_value_info(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & + value_info() const; + + // repeated .onnx.StringStringEntryProto metadata_props = 14; + int metadata_props_size() const; + +private: + int _internal_metadata_props_size() const; + +public: + void clear_metadata_props(); + ::onnx::StringStringEntryProto *mutable_metadata_props(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> * + mutable_metadata_props(); + +private: + const ::onnx::StringStringEntryProto & + _internal_metadata_props(int index) const; + ::onnx::StringStringEntryProto *_internal_add_metadata_props(); + +public: + const ::onnx::StringStringEntryProto &metadata_props(int index) const; + ::onnx::StringStringEntryProto *add_metadata_props(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & + metadata_props() const; + + // optional string name = 1; + bool has_name() const; + +private: + bool _internal_has_name() const; + +public: + void clear_name(); + const std::string &name() const; + template + void set_name(ArgT0 &&arg0, ArgT... args); + std::string *mutable_name(); + PROTOBUF_NODISCARD std::string *release_name(); + void set_allocated_name(std::string *name); + +private: + const std::string &_internal_name() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_name(const std::string &value); + std::string *_internal_mutable_name(); + +public: + // optional string doc_string = 8; + bool has_doc_string() const; + +private: + bool _internal_has_doc_string() const; + +public: + void clear_doc_string(); + const std::string &doc_string() const; + template + void set_doc_string(ArgT0 &&arg0, ArgT... args); + std::string *mutable_doc_string(); + PROTOBUF_NODISCARD std::string *release_doc_string(); + void set_allocated_doc_string(std::string *doc_string); + +private: + const std::string &_internal_doc_string() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_doc_string(const std::string &value); + std::string *_internal_mutable_doc_string(); + +public: + // optional string domain = 10; + bool has_domain() const; + +private: + bool _internal_has_domain() const; + +public: + void clear_domain(); + const std::string &domain() const; + template + void set_domain(ArgT0 &&arg0, ArgT... args); + std::string *mutable_domain(); + PROTOBUF_NODISCARD std::string *release_domain(); + void set_allocated_domain(std::string *domain); + +private: + const std::string &_internal_domain() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_domain(const std::string &value); + std::string *_internal_mutable_domain(); + +public: + // optional string overload = 13; + bool has_overload() const; + +private: + bool _internal_has_overload() const; + +public: + void clear_overload(); + const std::string &overload() const; + template + void set_overload(ArgT0 &&arg0, ArgT... args); + std::string *mutable_overload(); + PROTOBUF_NODISCARD std::string *release_overload(); + void set_allocated_overload(std::string *overload); + +private: + const std::string &_internal_overload() const; + inline PROTOBUF_ALWAYS_INLINE void + _internal_set_overload(const std::string &value); + std::string *_internal_mutable_overload(); + +public: + // @@protoc_insertion_point(class_scope:onnx.FunctionProto) +private: + class _Internal; + + template + friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField input_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField output_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField attribute_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> node_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> + opset_import_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> + attribute_proto_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> value_info_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + metadata_props_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr doc_string_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr domain_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr overload_; + friend struct ::TableStruct_onnx_2eproto; +}; +// =================================================================== + +// =================================================================== + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// AttributeProto + +// optional string name = 1; +inline bool AttributeProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool AttributeProto::has_name() const { return _internal_has_name(); } +inline void AttributeProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &AttributeProto::name() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.name) +} +inline std::string *AttributeProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.name) + return _s; +} +inline const std::string &AttributeProto::_internal_name() const { + return name_.Get(); +} +inline void AttributeProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *AttributeProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *AttributeProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void AttributeProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.name) +} + +// optional string ref_attr_name = 21; +inline bool AttributeProto::_internal_has_ref_attr_name() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool AttributeProto::has_ref_attr_name() const { + return _internal_has_ref_attr_name(); +} +inline void AttributeProto::clear_ref_attr_name() { + ref_attr_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string &AttributeProto::ref_attr_name() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.ref_attr_name) + return _internal_ref_attr_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +AttributeProto::set_ref_attr_name(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000008u; + ref_attr_name_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.ref_attr_name) +} +inline std::string *AttributeProto::mutable_ref_attr_name() { + std::string *_s = _internal_mutable_ref_attr_name(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.ref_attr_name) + return _s; +} +inline const std::string &AttributeProto::_internal_ref_attr_name() const { + return ref_attr_name_.Get(); +} +inline void +AttributeProto::_internal_set_ref_attr_name(const std::string &value) { + _has_bits_[0] |= 0x00000008u; + ref_attr_name_.Set(value, GetArenaForAllocation()); +} +inline std::string *AttributeProto::_internal_mutable_ref_attr_name() { + _has_bits_[0] |= 0x00000008u; + return ref_attr_name_.Mutable(GetArenaForAllocation()); +} +inline std::string *AttributeProto::release_ref_attr_name() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.ref_attr_name) + if (!_internal_has_ref_attr_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto *p = ref_attr_name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ref_attr_name_.IsDefault()) { + ref_attr_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void +AttributeProto::set_allocated_ref_attr_name(std::string *ref_attr_name) { + if (ref_attr_name != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + ref_attr_name_.SetAllocated(ref_attr_name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (ref_attr_name_.IsDefault()) { + ref_attr_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.ref_attr_name) +} + +// optional string doc_string = 13; +inline bool AttributeProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool AttributeProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void AttributeProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string &AttributeProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +AttributeProto::set_doc_string(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.doc_string) +} +inline std::string *AttributeProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.doc_string) + return _s; +} +inline const std::string &AttributeProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void AttributeProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *AttributeProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000004u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *AttributeProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void AttributeProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.doc_string) +} + +// optional .onnx.AttributeProto.AttributeType type = 20; +inline bool AttributeProto::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000400u) != 0; + return value; +} +inline bool AttributeProto::has_type() const { return _internal_has_type(); } +inline void AttributeProto::clear_type() { + type_ = 0; + _has_bits_[0] &= ~0x00000400u; +} +inline ::onnx::AttributeProto_AttributeType +AttributeProto::_internal_type() const { + return static_cast<::onnx::AttributeProto_AttributeType>(type_); +} +inline ::onnx::AttributeProto_AttributeType AttributeProto::type() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.type) + return _internal_type(); +} +inline void +AttributeProto::_internal_set_type(::onnx::AttributeProto_AttributeType value) { + assert(::onnx::AttributeProto_AttributeType_IsValid(value)); + _has_bits_[0] |= 0x00000400u; + type_ = value; +} +inline void +AttributeProto::set_type(::onnx::AttributeProto_AttributeType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.type) +} + +// optional float f = 2; +inline bool AttributeProto::_internal_has_f() const { + bool value = (_has_bits_[0] & 0x00000200u) != 0; + return value; +} +inline bool AttributeProto::has_f() const { return _internal_has_f(); } +inline void AttributeProto::clear_f() { + f_ = 0; + _has_bits_[0] &= ~0x00000200u; +} +inline float AttributeProto::_internal_f() const { return f_; } +inline float AttributeProto::f() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.f) + return _internal_f(); +} +inline void AttributeProto::_internal_set_f(float value) { + _has_bits_[0] |= 0x00000200u; + f_ = value; +} +inline void AttributeProto::set_f(float value) { + _internal_set_f(value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.f) +} + +// optional int64 i = 3; +inline bool AttributeProto::_internal_has_i() const { + bool value = (_has_bits_[0] & 0x00000100u) != 0; + return value; +} +inline bool AttributeProto::has_i() const { return _internal_has_i(); } +inline void AttributeProto::clear_i() { + i_ = int64_t{0}; + _has_bits_[0] &= ~0x00000100u; +} +inline int64_t AttributeProto::_internal_i() const { return i_; } +inline int64_t AttributeProto::i() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.i) + return _internal_i(); +} +inline void AttributeProto::_internal_set_i(int64_t value) { + _has_bits_[0] |= 0x00000100u; + i_ = value; +} +inline void AttributeProto::set_i(int64_t value) { + _internal_set_i(value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.i) +} + +// optional bytes s = 4; +inline bool AttributeProto::_internal_has_s() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool AttributeProto::has_s() const { return _internal_has_s(); } +inline void AttributeProto::clear_s() { + s_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &AttributeProto::s() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.s) + return _internal_s(); +} +template +inline PROTOBUF_ALWAYS_INLINE void AttributeProto::set_s(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000002u; + s_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.s) +} +inline std::string *AttributeProto::mutable_s() { + std::string *_s = _internal_mutable_s(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.s) + return _s; +} +inline const std::string &AttributeProto::_internal_s() const { + return s_.Get(); +} +inline void AttributeProto::_internal_set_s(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + s_.Set(value, GetArenaForAllocation()); +} +inline std::string *AttributeProto::_internal_mutable_s() { + _has_bits_[0] |= 0x00000002u; + return s_.Mutable(GetArenaForAllocation()); +} +inline std::string *AttributeProto::release_s() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.s) + if (!_internal_has_s()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = s_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (s_.IsDefault()) { + s_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void AttributeProto::set_allocated_s(std::string *s) { + if (s != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + s_.SetAllocated(s, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (s_.IsDefault()) { + s_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.s) +} + +// optional .onnx.TensorProto t = 5; +inline bool AttributeProto::_internal_has_t() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || t_ != nullptr); + return value; +} +inline bool AttributeProto::has_t() const { return _internal_has_t(); } +inline void AttributeProto::clear_t() { + if (t_ != nullptr) + t_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::onnx::TensorProto &AttributeProto::_internal_t() const { + const ::onnx::TensorProto *p = t_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorProto_default_instance_); +} +inline const ::onnx::TensorProto &AttributeProto::t() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.t) + return _internal_t(); +} +inline void +AttributeProto::unsafe_arena_set_allocated_t(::onnx::TensorProto *t) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(t_); + } + t_ = t; + if (t) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.t) +} +inline ::onnx::TensorProto *AttributeProto::release_t() { + _has_bits_[0] &= ~0x00000010u; + ::onnx::TensorProto *temp = t_; + t_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorProto *AttributeProto::unsafe_arena_release_t() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.t) + _has_bits_[0] &= ~0x00000010u; + ::onnx::TensorProto *temp = t_; + t_ = nullptr; + return temp; +} +inline ::onnx::TensorProto *AttributeProto::_internal_mutable_t() { + _has_bits_[0] |= 0x00000010u; + if (t_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TensorProto>(GetArenaForAllocation()); + t_ = p; + } + return t_; +} +inline ::onnx::TensorProto *AttributeProto::mutable_t() { + ::onnx::TensorProto *_msg = _internal_mutable_t(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.t) + return _msg; +} +inline void AttributeProto::set_allocated_t(::onnx::TensorProto *t) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete t_; + } + if (t) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(t); + if (message_arena != submessage_arena) { + t = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(message_arena, t, + submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + t_ = t; + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.t) +} + +// optional .onnx.GraphProto g = 6; +inline bool AttributeProto::_internal_has_g() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + PROTOBUF_ASSUME(!value || g_ != nullptr); + return value; +} +inline bool AttributeProto::has_g() const { return _internal_has_g(); } +inline void AttributeProto::clear_g() { + if (g_ != nullptr) + g_->Clear(); + _has_bits_[0] &= ~0x00000020u; +} +inline const ::onnx::GraphProto &AttributeProto::_internal_g() const { + const ::onnx::GraphProto *p = g_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_GraphProto_default_instance_); +} +inline const ::onnx::GraphProto &AttributeProto::g() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.g) + return _internal_g(); +} +inline void +AttributeProto::unsafe_arena_set_allocated_g(::onnx::GraphProto *g) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(g_); + } + g_ = g; + if (g) { + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.g) +} +inline ::onnx::GraphProto *AttributeProto::release_g() { + _has_bits_[0] &= ~0x00000020u; + ::onnx::GraphProto *temp = g_; + g_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::GraphProto *AttributeProto::unsafe_arena_release_g() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.g) + _has_bits_[0] &= ~0x00000020u; + ::onnx::GraphProto *temp = g_; + g_ = nullptr; + return temp; +} +inline ::onnx::GraphProto *AttributeProto::_internal_mutable_g() { + _has_bits_[0] |= 0x00000020u; + if (g_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::GraphProto>(GetArenaForAllocation()); + g_ = p; + } + return g_; +} +inline ::onnx::GraphProto *AttributeProto::mutable_g() { + ::onnx::GraphProto *_msg = _internal_mutable_g(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.g) + return _msg; +} +inline void AttributeProto::set_allocated_g(::onnx::GraphProto *g) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete g_; + } + if (g) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(g); + if (message_arena != submessage_arena) { + g = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(message_arena, g, + submessage_arena); + } + _has_bits_[0] |= 0x00000020u; + } else { + _has_bits_[0] &= ~0x00000020u; + } + g_ = g; + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.g) +} + +// optional .onnx.SparseTensorProto sparse_tensor = 22; +inline bool AttributeProto::_internal_has_sparse_tensor() const { + bool value = (_has_bits_[0] & 0x00000080u) != 0; + PROTOBUF_ASSUME(!value || sparse_tensor_ != nullptr); + return value; +} +inline bool AttributeProto::has_sparse_tensor() const { + return _internal_has_sparse_tensor(); +} +inline void AttributeProto::clear_sparse_tensor() { + if (sparse_tensor_ != nullptr) + sparse_tensor_->Clear(); + _has_bits_[0] &= ~0x00000080u; +} +inline const ::onnx::SparseTensorProto & +AttributeProto::_internal_sparse_tensor() const { + const ::onnx::SparseTensorProto *p = sparse_tensor_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_SparseTensorProto_default_instance_); +} +inline const ::onnx::SparseTensorProto &AttributeProto::sparse_tensor() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensor) + return _internal_sparse_tensor(); +} +inline void AttributeProto::unsafe_arena_set_allocated_sparse_tensor( + ::onnx::SparseTensorProto *sparse_tensor) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>( + sparse_tensor_); + } + sparse_tensor_ = sparse_tensor; + if (sparse_tensor) { + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.sparse_tensor) +} +inline ::onnx::SparseTensorProto *AttributeProto::release_sparse_tensor() { + _has_bits_[0] &= ~0x00000080u; + ::onnx::SparseTensorProto *temp = sparse_tensor_; + sparse_tensor_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::SparseTensorProto * +AttributeProto::unsafe_arena_release_sparse_tensor() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.sparse_tensor) + _has_bits_[0] &= ~0x00000080u; + ::onnx::SparseTensorProto *temp = sparse_tensor_; + sparse_tensor_ = nullptr; + return temp; +} +inline ::onnx::SparseTensorProto * +AttributeProto::_internal_mutable_sparse_tensor() { + _has_bits_[0] |= 0x00000080u; + if (sparse_tensor_ == nullptr) { + auto *p = + CreateMaybeMessage<::onnx::SparseTensorProto>(GetArenaForAllocation()); + sparse_tensor_ = p; + } + return sparse_tensor_; +} +inline ::onnx::SparseTensorProto *AttributeProto::mutable_sparse_tensor() { + ::onnx::SparseTensorProto *_msg = _internal_mutable_sparse_tensor(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensor) + return _msg; +} +inline void AttributeProto::set_allocated_sparse_tensor( + ::onnx::SparseTensorProto *sparse_tensor) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete sparse_tensor_; + } + if (sparse_tensor) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sparse_tensor); + if (message_arena != submessage_arena) { + sparse_tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sparse_tensor, submessage_arena); + } + _has_bits_[0] |= 0x00000080u; + } else { + _has_bits_[0] &= ~0x00000080u; + } + sparse_tensor_ = sparse_tensor; + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.sparse_tensor) +} + +// optional .onnx.TypeProto tp = 14; +inline bool AttributeProto::_internal_has_tp() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + PROTOBUF_ASSUME(!value || tp_ != nullptr); + return value; +} +inline bool AttributeProto::has_tp() const { return _internal_has_tp(); } +inline void AttributeProto::clear_tp() { + if (tp_ != nullptr) + tp_->Clear(); + _has_bits_[0] &= ~0x00000040u; +} +inline const ::onnx::TypeProto &AttributeProto::_internal_tp() const { + const ::onnx::TypeProto *p = tp_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TypeProto_default_instance_); +} +inline const ::onnx::TypeProto &AttributeProto::tp() const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.tp) + return _internal_tp(); +} +inline void +AttributeProto::unsafe_arena_set_allocated_tp(::onnx::TypeProto *tp) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(tp_); + } + tp_ = tp; + if (tp) { + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.AttributeProto.tp) +} +inline ::onnx::TypeProto *AttributeProto::release_tp() { + _has_bits_[0] &= ~0x00000040u; + ::onnx::TypeProto *temp = tp_; + tp_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TypeProto *AttributeProto::unsafe_arena_release_tp() { + // @@protoc_insertion_point(field_release:onnx.AttributeProto.tp) + _has_bits_[0] &= ~0x00000040u; + ::onnx::TypeProto *temp = tp_; + tp_ = nullptr; + return temp; +} +inline ::onnx::TypeProto *AttributeProto::_internal_mutable_tp() { + _has_bits_[0] |= 0x00000040u; + if (tp_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TypeProto>(GetArenaForAllocation()); + tp_ = p; + } + return tp_; +} +inline ::onnx::TypeProto *AttributeProto::mutable_tp() { + ::onnx::TypeProto *_msg = _internal_mutable_tp(); + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tp) + return _msg; +} +inline void AttributeProto::set_allocated_tp(::onnx::TypeProto *tp) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete tp_; + } + if (tp) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tp); + if (message_arena != submessage_arena) { + tp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(message_arena, tp, + submessage_arena); + } + _has_bits_[0] |= 0x00000040u; + } else { + _has_bits_[0] &= ~0x00000040u; + } + tp_ = tp; + // @@protoc_insertion_point(field_set_allocated:onnx.AttributeProto.tp) +} + +// repeated float floats = 7; +inline int AttributeProto::_internal_floats_size() const { + return floats_.size(); +} +inline int AttributeProto::floats_size() const { + return _internal_floats_size(); +} +inline void AttributeProto::clear_floats() { floats_.Clear(); } +inline float AttributeProto::_internal_floats(int index) const { + return floats_.Get(index); +} +inline float AttributeProto::floats(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.floats) + return _internal_floats(index); +} +inline void AttributeProto::set_floats(int index, float value) { + floats_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.floats) +} +inline void AttributeProto::_internal_add_floats(float value) { + floats_.Add(value); +} +inline void AttributeProto::add_floats(float value) { + _internal_add_floats(value); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.floats) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +AttributeProto::_internal_floats() const { + return floats_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +AttributeProto::floats() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.floats) + return _internal_floats(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +AttributeProto::_internal_mutable_floats() { + return &floats_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +AttributeProto::mutable_floats() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.floats) + return _internal_mutable_floats(); +} + +// repeated int64 ints = 8; +inline int AttributeProto::_internal_ints_size() const { return ints_.size(); } +inline int AttributeProto::ints_size() const { return _internal_ints_size(); } +inline void AttributeProto::clear_ints() { ints_.Clear(); } +inline int64_t AttributeProto::_internal_ints(int index) const { + return ints_.Get(index); +} +inline int64_t AttributeProto::ints(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.ints) + return _internal_ints(index); +} +inline void AttributeProto::set_ints(int index, int64_t value) { + ints_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.ints) +} +inline void AttributeProto::_internal_add_ints(int64_t value) { + ints_.Add(value); +} +inline void AttributeProto::add_ints(int64_t value) { + _internal_add_ints(value); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.ints) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +AttributeProto::_internal_ints() const { + return ints_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +AttributeProto::ints() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.ints) + return _internal_ints(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +AttributeProto::_internal_mutable_ints() { + return &ints_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +AttributeProto::mutable_ints() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.ints) + return _internal_mutable_ints(); +} + +// repeated bytes strings = 9; +inline int AttributeProto::_internal_strings_size() const { + return strings_.size(); +} +inline int AttributeProto::strings_size() const { + return _internal_strings_size(); +} +inline void AttributeProto::clear_strings() { strings_.Clear(); } +inline std::string *AttributeProto::add_strings() { + std::string *_s = _internal_add_strings(); + // @@protoc_insertion_point(field_add_mutable:onnx.AttributeProto.strings) + return _s; +} +inline const std::string &AttributeProto::_internal_strings(int index) const { + return strings_.Get(index); +} +inline const std::string &AttributeProto::strings(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.strings) + return _internal_strings(index); +} +inline std::string *AttributeProto::mutable_strings(int index) { + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.strings) + return strings_.Mutable(index); +} +inline void AttributeProto::set_strings(int index, const std::string &value) { + strings_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings) +} +inline void AttributeProto::set_strings(int index, std::string &&value) { + strings_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.AttributeProto.strings) +} +inline void AttributeProto::set_strings(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + strings_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char: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:onnx.AttributeProto.strings) +} +inline std::string *AttributeProto::_internal_add_strings() { + return strings_.Add(); +} +inline void AttributeProto::add_strings(const std::string &value) { + strings_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings) +} +inline void AttributeProto::add_strings(std::string &&value) { + strings_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.strings) +} +inline void AttributeProto::add_strings(const char *value) { + GOOGLE_DCHECK(value != nullptr); + strings_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char: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:onnx.AttributeProto.strings) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +AttributeProto::strings() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.strings) + return strings_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +AttributeProto::mutable_strings() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.strings) + return &strings_; +} + +// repeated .onnx.TensorProto tensors = 10; +inline int AttributeProto::_internal_tensors_size() const { + return tensors_.size(); +} +inline int AttributeProto::tensors_size() const { + return _internal_tensors_size(); +} +inline void AttributeProto::clear_tensors() { tensors_.Clear(); } +inline ::onnx::TensorProto *AttributeProto::mutable_tensors(int index) { + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.tensors) + return tensors_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> * +AttributeProto::mutable_tensors() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.tensors) + return &tensors_; +} +inline const ::onnx::TensorProto & +AttributeProto::_internal_tensors(int index) const { + return tensors_.Get(index); +} +inline const ::onnx::TensorProto &AttributeProto::tensors(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.tensors) + return _internal_tensors(index); +} +inline ::onnx::TensorProto *AttributeProto::_internal_add_tensors() { + return tensors_.Add(); +} +inline ::onnx::TensorProto *AttributeProto::add_tensors() { + ::onnx::TensorProto *_add = _internal_add_tensors(); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.tensors) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> & +AttributeProto::tensors() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.tensors) + return tensors_; +} + +// repeated .onnx.GraphProto graphs = 11; +inline int AttributeProto::_internal_graphs_size() const { + return graphs_.size(); +} +inline int AttributeProto::graphs_size() const { + return _internal_graphs_size(); +} +inline void AttributeProto::clear_graphs() { graphs_.Clear(); } +inline ::onnx::GraphProto *AttributeProto::mutable_graphs(int index) { + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.graphs) + return graphs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::GraphProto> * +AttributeProto::mutable_graphs() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.graphs) + return &graphs_; +} +inline const ::onnx::GraphProto & +AttributeProto::_internal_graphs(int index) const { + return graphs_.Get(index); +} +inline const ::onnx::GraphProto &AttributeProto::graphs(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.graphs) + return _internal_graphs(index); +} +inline ::onnx::GraphProto *AttributeProto::_internal_add_graphs() { + return graphs_.Add(); +} +inline ::onnx::GraphProto *AttributeProto::add_graphs() { + ::onnx::GraphProto *_add = _internal_add_graphs(); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.graphs) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::GraphProto> & +AttributeProto::graphs() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.graphs) + return graphs_; +} + +// repeated .onnx.SparseTensorProto sparse_tensors = 23; +inline int AttributeProto::_internal_sparse_tensors_size() const { + return sparse_tensors_.size(); +} +inline int AttributeProto::sparse_tensors_size() const { + return _internal_sparse_tensors_size(); +} +inline void AttributeProto::clear_sparse_tensors() { sparse_tensors_.Clear(); } +inline ::onnx::SparseTensorProto * +AttributeProto::mutable_sparse_tensors(int index) { + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.sparse_tensors) + return sparse_tensors_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> * +AttributeProto::mutable_sparse_tensors() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.sparse_tensors) + return &sparse_tensors_; +} +inline const ::onnx::SparseTensorProto & +AttributeProto::_internal_sparse_tensors(int index) const { + return sparse_tensors_.Get(index); +} +inline const ::onnx::SparseTensorProto & +AttributeProto::sparse_tensors(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.sparse_tensors) + return _internal_sparse_tensors(index); +} +inline ::onnx::SparseTensorProto * +AttributeProto::_internal_add_sparse_tensors() { + return sparse_tensors_.Add(); +} +inline ::onnx::SparseTensorProto *AttributeProto::add_sparse_tensors() { + ::onnx::SparseTensorProto *_add = _internal_add_sparse_tensors(); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.sparse_tensors) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::SparseTensorProto> & +AttributeProto::sparse_tensors() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.sparse_tensors) + return sparse_tensors_; +} + +// repeated .onnx.TypeProto type_protos = 15; +inline int AttributeProto::_internal_type_protos_size() const { + return type_protos_.size(); +} +inline int AttributeProto::type_protos_size() const { + return _internal_type_protos_size(); +} +inline void AttributeProto::clear_type_protos() { type_protos_.Clear(); } +inline ::onnx::TypeProto *AttributeProto::mutable_type_protos(int index) { + // @@protoc_insertion_point(field_mutable:onnx.AttributeProto.type_protos) + return type_protos_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TypeProto> * +AttributeProto::mutable_type_protos() { + // @@protoc_insertion_point(field_mutable_list:onnx.AttributeProto.type_protos) + return &type_protos_; +} +inline const ::onnx::TypeProto & +AttributeProto::_internal_type_protos(int index) const { + return type_protos_.Get(index); +} +inline const ::onnx::TypeProto &AttributeProto::type_protos(int index) const { + // @@protoc_insertion_point(field_get:onnx.AttributeProto.type_protos) + return _internal_type_protos(index); +} +inline ::onnx::TypeProto *AttributeProto::_internal_add_type_protos() { + return type_protos_.Add(); +} +inline ::onnx::TypeProto *AttributeProto::add_type_protos() { + ::onnx::TypeProto *_add = _internal_add_type_protos(); + // @@protoc_insertion_point(field_add:onnx.AttributeProto.type_protos) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TypeProto> & +AttributeProto::type_protos() const { + // @@protoc_insertion_point(field_list:onnx.AttributeProto.type_protos) + return type_protos_; +} + +// ------------------------------------------------------------------- + +// ValueInfoProto + +// optional string name = 1; +inline bool ValueInfoProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ValueInfoProto::has_name() const { return _internal_has_name(); } +inline void ValueInfoProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &ValueInfoProto::name() const { + // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ValueInfoProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.name) +} +inline std::string *ValueInfoProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.name) + return _s; +} +inline const std::string &ValueInfoProto::_internal_name() const { + return name_.Get(); +} +inline void ValueInfoProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *ValueInfoProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *ValueInfoProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ValueInfoProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.name) +} + +// optional .onnx.TypeProto type = 2; +inline bool ValueInfoProto::_internal_has_type() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + PROTOBUF_ASSUME(!value || type_ != nullptr); + return value; +} +inline bool ValueInfoProto::has_type() const { return _internal_has_type(); } +inline void ValueInfoProto::clear_type() { + if (type_ != nullptr) + type_->Clear(); + _has_bits_[0] &= ~0x00000004u; +} +inline const ::onnx::TypeProto &ValueInfoProto::_internal_type() const { + const ::onnx::TypeProto *p = type_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TypeProto_default_instance_); +} +inline const ::onnx::TypeProto &ValueInfoProto::type() const { + // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.type) + return _internal_type(); +} +inline void +ValueInfoProto::unsafe_arena_set_allocated_type(::onnx::TypeProto *type) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(type_); + } + type_ = type; + if (type) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ValueInfoProto.type) +} +inline ::onnx::TypeProto *ValueInfoProto::release_type() { + _has_bits_[0] &= ~0x00000004u; + ::onnx::TypeProto *temp = type_; + type_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TypeProto *ValueInfoProto::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.type) + _has_bits_[0] &= ~0x00000004u; + ::onnx::TypeProto *temp = type_; + type_ = nullptr; + return temp; +} +inline ::onnx::TypeProto *ValueInfoProto::_internal_mutable_type() { + _has_bits_[0] |= 0x00000004u; + if (type_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TypeProto>(GetArenaForAllocation()); + type_ = p; + } + return type_; +} +inline ::onnx::TypeProto *ValueInfoProto::mutable_type() { + ::onnx::TypeProto *_msg = _internal_mutable_type(); + // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.type) + return _msg; +} +inline void ValueInfoProto::set_allocated_type(::onnx::TypeProto *type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(type); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.type) +} + +// optional string doc_string = 3; +inline bool ValueInfoProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ValueInfoProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void ValueInfoProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &ValueInfoProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +ValueInfoProto::set_doc_string(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ValueInfoProto.doc_string) +} +inline std::string *ValueInfoProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.doc_string) + return _s; +} +inline const std::string &ValueInfoProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void ValueInfoProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *ValueInfoProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000002u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *ValueInfoProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.ValueInfoProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ValueInfoProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ValueInfoProto.doc_string) +} + +// repeated .onnx.StringStringEntryProto metadata_props = 4; +inline int ValueInfoProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int ValueInfoProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void ValueInfoProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +ValueInfoProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.ValueInfoProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *ValueInfoProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.ValueInfoProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +ValueInfoProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +ValueInfoProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.ValueInfoProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +ValueInfoProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *ValueInfoProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.ValueInfoProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +ValueInfoProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.ValueInfoProto.metadata_props) + return metadata_props_; +} + +// ------------------------------------------------------------------- + +// NodeProto + +// repeated string input = 1; +inline int NodeProto::_internal_input_size() const { return input_.size(); } +inline int NodeProto::input_size() const { return _internal_input_size(); } +inline void NodeProto::clear_input() { input_.Clear(); } +inline std::string *NodeProto::add_input() { + std::string *_s = _internal_add_input(); + // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.input) + return _s; +} +inline const std::string &NodeProto::_internal_input(int index) const { + return input_.Get(index); +} +inline const std::string &NodeProto::input(int index) const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.input) + return _internal_input(index); +} +inline std::string *NodeProto::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.input) + return input_.Mutable(index); +} +inline void NodeProto::set_input(int index, const std::string &value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.NodeProto.input) +} +inline void NodeProto::set_input(int index, std::string &&value) { + input_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.NodeProto.input) +} +inline void NodeProto::set_input(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char: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:onnx.NodeProto.input) +} +inline std::string *NodeProto::_internal_add_input() { return input_.Add(); } +inline void NodeProto::add_input(const std::string &value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.NodeProto.input) +} +inline void NodeProto::add_input(std::string &&value) { + input_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.NodeProto.input) +} +inline void NodeProto::add_input(const char *value) { + GOOGLE_DCHECK(value != nullptr); + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char: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:onnx.NodeProto.input) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +NodeProto::input() const { + // @@protoc_insertion_point(field_list:onnx.NodeProto.input) + return input_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +NodeProto::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.input) + return &input_; +} + +// repeated string output = 2; +inline int NodeProto::_internal_output_size() const { return output_.size(); } +inline int NodeProto::output_size() const { return _internal_output_size(); } +inline void NodeProto::clear_output() { output_.Clear(); } +inline std::string *NodeProto::add_output() { + std::string *_s = _internal_add_output(); + // @@protoc_insertion_point(field_add_mutable:onnx.NodeProto.output) + return _s; +} +inline const std::string &NodeProto::_internal_output(int index) const { + return output_.Get(index); +} +inline const std::string &NodeProto::output(int index) const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.output) + return _internal_output(index); +} +inline std::string *NodeProto::mutable_output(int index) { + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.output) + return output_.Mutable(index); +} +inline void NodeProto::set_output(int index, const std::string &value) { + output_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.NodeProto.output) +} +inline void NodeProto::set_output(int index, std::string &&value) { + output_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.NodeProto.output) +} +inline void NodeProto::set_output(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + output_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char: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:onnx.NodeProto.output) +} +inline std::string *NodeProto::_internal_add_output() { return output_.Add(); } +inline void NodeProto::add_output(const std::string &value) { + output_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.NodeProto.output) +} +inline void NodeProto::add_output(std::string &&value) { + output_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.NodeProto.output) +} +inline void NodeProto::add_output(const char *value) { + GOOGLE_DCHECK(value != nullptr); + output_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char: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:onnx.NodeProto.output) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +NodeProto::output() const { + // @@protoc_insertion_point(field_list:onnx.NodeProto.output) + return output_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +NodeProto::mutable_output() { + // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.output) + return &output_; +} + +// optional string name = 3; +inline bool NodeProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool NodeProto::has_name() const { return _internal_has_name(); } +inline void NodeProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &NodeProto::name() const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.NodeProto.name) +} +inline std::string *NodeProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.name) + return _s; +} +inline const std::string &NodeProto::_internal_name() const { + return name_.Get(); +} +inline void NodeProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *NodeProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *NodeProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.NodeProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NodeProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.name) +} + +// optional string op_type = 4; +inline bool NodeProto::_internal_has_op_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool NodeProto::has_op_type() const { return _internal_has_op_type(); } +inline void NodeProto::clear_op_type() { + op_type_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &NodeProto::op_type() const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.op_type) + return _internal_op_type(); +} +template +inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_op_type(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000002u; + op_type_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.NodeProto.op_type) +} +inline std::string *NodeProto::mutable_op_type() { + std::string *_s = _internal_mutable_op_type(); + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.op_type) + return _s; +} +inline const std::string &NodeProto::_internal_op_type() const { + return op_type_.Get(); +} +inline void NodeProto::_internal_set_op_type(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + op_type_.Set(value, GetArenaForAllocation()); +} +inline std::string *NodeProto::_internal_mutable_op_type() { + _has_bits_[0] |= 0x00000002u; + return op_type_.Mutable(GetArenaForAllocation()); +} +inline std::string *NodeProto::release_op_type() { + // @@protoc_insertion_point(field_release:onnx.NodeProto.op_type) + if (!_internal_has_op_type()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = op_type_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (op_type_.IsDefault()) { + op_type_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NodeProto::set_allocated_op_type(std::string *op_type) { + if (op_type != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + op_type_.SetAllocated(op_type, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (op_type_.IsDefault()) { + op_type_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.op_type) +} + +// optional string domain = 7; +inline bool NodeProto::_internal_has_domain() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool NodeProto::has_domain() const { return _internal_has_domain(); } +inline void NodeProto::clear_domain() { + domain_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string &NodeProto::domain() const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.domain) + return _internal_domain(); +} +template +inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_domain(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000008u; + domain_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.NodeProto.domain) +} +inline std::string *NodeProto::mutable_domain() { + std::string *_s = _internal_mutable_domain(); + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.domain) + return _s; +} +inline const std::string &NodeProto::_internal_domain() const { + return domain_.Get(); +} +inline void NodeProto::_internal_set_domain(const std::string &value) { + _has_bits_[0] |= 0x00000008u; + domain_.Set(value, GetArenaForAllocation()); +} +inline std::string *NodeProto::_internal_mutable_domain() { + _has_bits_[0] |= 0x00000008u; + return domain_.Mutable(GetArenaForAllocation()); +} +inline std::string *NodeProto::release_domain() { + // @@protoc_insertion_point(field_release:onnx.NodeProto.domain) + if (!_internal_has_domain()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto *p = domain_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NodeProto::set_allocated_domain(std::string *domain) { + if (domain != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + domain_.SetAllocated(domain, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.domain) +} + +// optional string overload = 8; +inline bool NodeProto::_internal_has_overload() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool NodeProto::has_overload() const { return _internal_has_overload(); } +inline void NodeProto::clear_overload() { + overload_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000010u; +} +inline const std::string &NodeProto::overload() const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.overload) + return _internal_overload(); +} +template +inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_overload(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000010u; + overload_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.NodeProto.overload) +} +inline std::string *NodeProto::mutable_overload() { + std::string *_s = _internal_mutable_overload(); + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.overload) + return _s; +} +inline const std::string &NodeProto::_internal_overload() const { + return overload_.Get(); +} +inline void NodeProto::_internal_set_overload(const std::string &value) { + _has_bits_[0] |= 0x00000010u; + overload_.Set(value, GetArenaForAllocation()); +} +inline std::string *NodeProto::_internal_mutable_overload() { + _has_bits_[0] |= 0x00000010u; + return overload_.Mutable(GetArenaForAllocation()); +} +inline std::string *NodeProto::release_overload() { + // @@protoc_insertion_point(field_release:onnx.NodeProto.overload) + if (!_internal_has_overload()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000010u; + auto *p = overload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (overload_.IsDefault()) { + overload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NodeProto::set_allocated_overload(std::string *overload) { + if (overload != nullptr) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + overload_.SetAllocated(overload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (overload_.IsDefault()) { + overload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.overload) +} + +// repeated .onnx.AttributeProto attribute = 5; +inline int NodeProto::_internal_attribute_size() const { + return attribute_.size(); +} +inline int NodeProto::attribute_size() const { + return _internal_attribute_size(); +} +inline void NodeProto::clear_attribute() { attribute_.Clear(); } +inline ::onnx::AttributeProto *NodeProto::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.attribute) + return attribute_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> * +NodeProto::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.attribute) + return &attribute_; +} +inline const ::onnx::AttributeProto & +NodeProto::_internal_attribute(int index) const { + return attribute_.Get(index); +} +inline const ::onnx::AttributeProto &NodeProto::attribute(int index) const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.attribute) + return _internal_attribute(index); +} +inline ::onnx::AttributeProto *NodeProto::_internal_add_attribute() { + return attribute_.Add(); +} +inline ::onnx::AttributeProto *NodeProto::add_attribute() { + ::onnx::AttributeProto *_add = _internal_add_attribute(); + // @@protoc_insertion_point(field_add:onnx.NodeProto.attribute) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> & +NodeProto::attribute() const { + // @@protoc_insertion_point(field_list:onnx.NodeProto.attribute) + return attribute_; +} + +// optional string doc_string = 6; +inline bool NodeProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool NodeProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void NodeProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string &NodeProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void NodeProto::set_doc_string(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.NodeProto.doc_string) +} +inline std::string *NodeProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.doc_string) + return _s; +} +inline const std::string &NodeProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void NodeProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *NodeProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000004u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *NodeProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.NodeProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void NodeProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.NodeProto.doc_string) +} + +// repeated .onnx.StringStringEntryProto metadata_props = 9; +inline int NodeProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int NodeProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void NodeProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +NodeProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.NodeProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *NodeProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.NodeProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +NodeProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +NodeProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.NodeProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +NodeProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *NodeProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.NodeProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +NodeProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.NodeProto.metadata_props) + return metadata_props_; +} + +// ------------------------------------------------------------------- + +// TrainingInfoProto + +// optional .onnx.GraphProto initialization = 1; +inline bool TrainingInfoProto::_internal_has_initialization() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || initialization_ != nullptr); + return value; +} +inline bool TrainingInfoProto::has_initialization() const { + return _internal_has_initialization(); +} +inline void TrainingInfoProto::clear_initialization() { + if (initialization_ != nullptr) + initialization_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::GraphProto & +TrainingInfoProto::_internal_initialization() const { + const ::onnx::GraphProto *p = initialization_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_GraphProto_default_instance_); +} +inline const ::onnx::GraphProto &TrainingInfoProto::initialization() const { + // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization) + return _internal_initialization(); +} +inline void TrainingInfoProto::unsafe_arena_set_allocated_initialization( + ::onnx::GraphProto *initialization) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>( + initialization_); + } + initialization_ = initialization; + if (initialization) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.initialization) +} +inline ::onnx::GraphProto *TrainingInfoProto::release_initialization() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::GraphProto *temp = initialization_; + initialization_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::GraphProto * +TrainingInfoProto::unsafe_arena_release_initialization() { + // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.initialization) + _has_bits_[0] &= ~0x00000001u; + ::onnx::GraphProto *temp = initialization_; + initialization_ = nullptr; + return temp; +} +inline ::onnx::GraphProto * +TrainingInfoProto::_internal_mutable_initialization() { + _has_bits_[0] |= 0x00000001u; + if (initialization_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::GraphProto>(GetArenaForAllocation()); + initialization_ = p; + } + return initialization_; +} +inline ::onnx::GraphProto *TrainingInfoProto::mutable_initialization() { + ::onnx::GraphProto *_msg = _internal_mutable_initialization(); + // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization) + return _msg; +} +inline void TrainingInfoProto::set_allocated_initialization( + ::onnx::GraphProto *initialization) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete initialization_; + } + if (initialization) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(initialization); + if (message_arena != submessage_arena) { + initialization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, initialization, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + initialization_ = initialization; + // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.initialization) +} + +// optional .onnx.GraphProto algorithm = 2; +inline bool TrainingInfoProto::_internal_has_algorithm() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || algorithm_ != nullptr); + return value; +} +inline bool TrainingInfoProto::has_algorithm() const { + return _internal_has_algorithm(); +} +inline void TrainingInfoProto::clear_algorithm() { + if (algorithm_ != nullptr) + algorithm_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::onnx::GraphProto & +TrainingInfoProto::_internal_algorithm() const { + const ::onnx::GraphProto *p = algorithm_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_GraphProto_default_instance_); +} +inline const ::onnx::GraphProto &TrainingInfoProto::algorithm() const { + // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.algorithm) + return _internal_algorithm(); +} +inline void TrainingInfoProto::unsafe_arena_set_allocated_algorithm( + ::onnx::GraphProto *algorithm) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(algorithm_); + } + algorithm_ = algorithm; + if (algorithm) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TrainingInfoProto.algorithm) +} +inline ::onnx::GraphProto *TrainingInfoProto::release_algorithm() { + _has_bits_[0] &= ~0x00000002u; + ::onnx::GraphProto *temp = algorithm_; + algorithm_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::GraphProto *TrainingInfoProto::unsafe_arena_release_algorithm() { + // @@protoc_insertion_point(field_release:onnx.TrainingInfoProto.algorithm) + _has_bits_[0] &= ~0x00000002u; + ::onnx::GraphProto *temp = algorithm_; + algorithm_ = nullptr; + return temp; +} +inline ::onnx::GraphProto *TrainingInfoProto::_internal_mutable_algorithm() { + _has_bits_[0] |= 0x00000002u; + if (algorithm_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::GraphProto>(GetArenaForAllocation()); + algorithm_ = p; + } + return algorithm_; +} +inline ::onnx::GraphProto *TrainingInfoProto::mutable_algorithm() { + ::onnx::GraphProto *_msg = _internal_mutable_algorithm(); + // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.algorithm) + return _msg; +} +inline void +TrainingInfoProto::set_allocated_algorithm(::onnx::GraphProto *algorithm) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete algorithm_; + } + if (algorithm) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(algorithm); + if (message_arena != submessage_arena) { + algorithm = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, algorithm, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + algorithm_ = algorithm; + // @@protoc_insertion_point(field_set_allocated:onnx.TrainingInfoProto.algorithm) +} + +// repeated .onnx.StringStringEntryProto initialization_binding = 3; +inline int TrainingInfoProto::_internal_initialization_binding_size() const { + return initialization_binding_.size(); +} +inline int TrainingInfoProto::initialization_binding_size() const { + return _internal_initialization_binding_size(); +} +inline void TrainingInfoProto::clear_initialization_binding() { + initialization_binding_.Clear(); +} +inline ::onnx::StringStringEntryProto * +TrainingInfoProto::mutable_initialization_binding(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.initialization_binding) + return initialization_binding_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *TrainingInfoProto::mutable_initialization_binding() { + // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.initialization_binding) + return &initialization_binding_; +} +inline const ::onnx::StringStringEntryProto & +TrainingInfoProto::_internal_initialization_binding(int index) const { + return initialization_binding_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +TrainingInfoProto::initialization_binding(int index) const { + // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.initialization_binding) + return _internal_initialization_binding(index); +} +inline ::onnx::StringStringEntryProto * +TrainingInfoProto::_internal_add_initialization_binding() { + return initialization_binding_.Add(); +} +inline ::onnx::StringStringEntryProto * +TrainingInfoProto::add_initialization_binding() { + ::onnx::StringStringEntryProto *_add = _internal_add_initialization_binding(); + // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.initialization_binding) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +TrainingInfoProto::initialization_binding() const { + // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.initialization_binding) + return initialization_binding_; +} + +// repeated .onnx.StringStringEntryProto update_binding = 4; +inline int TrainingInfoProto::_internal_update_binding_size() const { + return update_binding_.size(); +} +inline int TrainingInfoProto::update_binding_size() const { + return _internal_update_binding_size(); +} +inline void TrainingInfoProto::clear_update_binding() { + update_binding_.Clear(); +} +inline ::onnx::StringStringEntryProto * +TrainingInfoProto::mutable_update_binding(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TrainingInfoProto.update_binding) + return update_binding_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *TrainingInfoProto::mutable_update_binding() { + // @@protoc_insertion_point(field_mutable_list:onnx.TrainingInfoProto.update_binding) + return &update_binding_; +} +inline const ::onnx::StringStringEntryProto & +TrainingInfoProto::_internal_update_binding(int index) const { + return update_binding_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +TrainingInfoProto::update_binding(int index) const { + // @@protoc_insertion_point(field_get:onnx.TrainingInfoProto.update_binding) + return _internal_update_binding(index); +} +inline ::onnx::StringStringEntryProto * +TrainingInfoProto::_internal_add_update_binding() { + return update_binding_.Add(); +} +inline ::onnx::StringStringEntryProto *TrainingInfoProto::add_update_binding() { + ::onnx::StringStringEntryProto *_add = _internal_add_update_binding(); + // @@protoc_insertion_point(field_add:onnx.TrainingInfoProto.update_binding) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +TrainingInfoProto::update_binding() const { + // @@protoc_insertion_point(field_list:onnx.TrainingInfoProto.update_binding) + return update_binding_; +} + +// ------------------------------------------------------------------- + +// ModelProto + +// optional int64 ir_version = 1; +inline bool ModelProto::_internal_has_ir_version() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool ModelProto::has_ir_version() const { + return _internal_has_ir_version(); +} +inline void ModelProto::clear_ir_version() { + ir_version_ = int64_t{0}; + _has_bits_[0] &= ~0x00000020u; +} +inline int64_t ModelProto::_internal_ir_version() const { return ir_version_; } +inline int64_t ModelProto::ir_version() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.ir_version) + return _internal_ir_version(); +} +inline void ModelProto::_internal_set_ir_version(int64_t value) { + _has_bits_[0] |= 0x00000020u; + ir_version_ = value; +} +inline void ModelProto::set_ir_version(int64_t value) { + _internal_set_ir_version(value); + // @@protoc_insertion_point(field_set:onnx.ModelProto.ir_version) +} + +// repeated .onnx.OperatorSetIdProto opset_import = 8; +inline int ModelProto::_internal_opset_import_size() const { + return opset_import_.size(); +} +inline int ModelProto::opset_import_size() const { + return _internal_opset_import_size(); +} +inline void ModelProto::clear_opset_import() { opset_import_.Clear(); } +inline ::onnx::OperatorSetIdProto *ModelProto::mutable_opset_import(int index) { + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.opset_import) + return opset_import_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> * +ModelProto::mutable_opset_import() { + // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.opset_import) + return &opset_import_; +} +inline const ::onnx::OperatorSetIdProto & +ModelProto::_internal_opset_import(int index) const { + return opset_import_.Get(index); +} +inline const ::onnx::OperatorSetIdProto & +ModelProto::opset_import(int index) const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.opset_import) + return _internal_opset_import(index); +} +inline ::onnx::OperatorSetIdProto *ModelProto::_internal_add_opset_import() { + return opset_import_.Add(); +} +inline ::onnx::OperatorSetIdProto *ModelProto::add_opset_import() { + ::onnx::OperatorSetIdProto *_add = _internal_add_opset_import(); + // @@protoc_insertion_point(field_add:onnx.ModelProto.opset_import) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::OperatorSetIdProto> & +ModelProto::opset_import() const { + // @@protoc_insertion_point(field_list:onnx.ModelProto.opset_import) + return opset_import_; +} + +// optional string producer_name = 2; +inline bool ModelProto::_internal_has_producer_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool ModelProto::has_producer_name() const { + return _internal_has_producer_name(); +} +inline void ModelProto::clear_producer_name() { + producer_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &ModelProto::producer_name() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_name) + return _internal_producer_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_producer_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + producer_name_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_name) +} +inline std::string *ModelProto::mutable_producer_name() { + std::string *_s = _internal_mutable_producer_name(); + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_name) + return _s; +} +inline const std::string &ModelProto::_internal_producer_name() const { + return producer_name_.Get(); +} +inline void ModelProto::_internal_set_producer_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + producer_name_.Set(value, GetArenaForAllocation()); +} +inline std::string *ModelProto::_internal_mutable_producer_name() { + _has_bits_[0] |= 0x00000001u; + return producer_name_.Mutable(GetArenaForAllocation()); +} +inline std::string *ModelProto::release_producer_name() { + // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_name) + if (!_internal_has_producer_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = producer_name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (producer_name_.IsDefault()) { + producer_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void +ModelProto::set_allocated_producer_name(std::string *producer_name) { + if (producer_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + producer_name_.SetAllocated(producer_name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (producer_name_.IsDefault()) { + producer_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_name) +} + +// optional string producer_version = 3; +inline bool ModelProto::_internal_has_producer_version() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool ModelProto::has_producer_version() const { + return _internal_has_producer_version(); +} +inline void ModelProto::clear_producer_version() { + producer_version_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &ModelProto::producer_version() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.producer_version) + return _internal_producer_version(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +ModelProto::set_producer_version(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + producer_version_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ModelProto.producer_version) +} +inline std::string *ModelProto::mutable_producer_version() { + std::string *_s = _internal_mutable_producer_version(); + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.producer_version) + return _s; +} +inline const std::string &ModelProto::_internal_producer_version() const { + return producer_version_.Get(); +} +inline void +ModelProto::_internal_set_producer_version(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + producer_version_.Set(value, GetArenaForAllocation()); +} +inline std::string *ModelProto::_internal_mutable_producer_version() { + _has_bits_[0] |= 0x00000002u; + return producer_version_.Mutable(GetArenaForAllocation()); +} +inline std::string *ModelProto::release_producer_version() { + // @@protoc_insertion_point(field_release:onnx.ModelProto.producer_version) + if (!_internal_has_producer_version()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = producer_version_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (producer_version_.IsDefault()) { + producer_version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void +ModelProto::set_allocated_producer_version(std::string *producer_version) { + if (producer_version != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + producer_version_.SetAllocated(producer_version, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (producer_version_.IsDefault()) { + producer_version_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.producer_version) +} + +// optional string domain = 4; +inline bool ModelProto::_internal_has_domain() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool ModelProto::has_domain() const { return _internal_has_domain(); } +inline void ModelProto::clear_domain() { + domain_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string &ModelProto::domain() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.domain) + return _internal_domain(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_domain(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000004u; + domain_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ModelProto.domain) +} +inline std::string *ModelProto::mutable_domain() { + std::string *_s = _internal_mutable_domain(); + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.domain) + return _s; +} +inline const std::string &ModelProto::_internal_domain() const { + return domain_.Get(); +} +inline void ModelProto::_internal_set_domain(const std::string &value) { + _has_bits_[0] |= 0x00000004u; + domain_.Set(value, GetArenaForAllocation()); +} +inline std::string *ModelProto::_internal_mutable_domain() { + _has_bits_[0] |= 0x00000004u; + return domain_.Mutable(GetArenaForAllocation()); +} +inline std::string *ModelProto::release_domain() { + // @@protoc_insertion_point(field_release:onnx.ModelProto.domain) + if (!_internal_has_domain()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto *p = domain_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ModelProto::set_allocated_domain(std::string *domain) { + if (domain != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + domain_.SetAllocated(domain, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.domain) +} + +// optional int64 model_version = 5; +inline bool ModelProto::_internal_has_model_version() const { + bool value = (_has_bits_[0] & 0x00000040u) != 0; + return value; +} +inline bool ModelProto::has_model_version() const { + return _internal_has_model_version(); +} +inline void ModelProto::clear_model_version() { + model_version_ = int64_t{0}; + _has_bits_[0] &= ~0x00000040u; +} +inline int64_t ModelProto::_internal_model_version() const { + return model_version_; +} +inline int64_t ModelProto::model_version() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.model_version) + return _internal_model_version(); +} +inline void ModelProto::_internal_set_model_version(int64_t value) { + _has_bits_[0] |= 0x00000040u; + model_version_ = value; +} +inline void ModelProto::set_model_version(int64_t value) { + _internal_set_model_version(value); + // @@protoc_insertion_point(field_set:onnx.ModelProto.model_version) +} + +// optional string doc_string = 6; +inline bool ModelProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool ModelProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void ModelProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string &ModelProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ModelProto::set_doc_string(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000008u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.ModelProto.doc_string) +} +inline std::string *ModelProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.doc_string) + return _s; +} +inline const std::string &ModelProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void ModelProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000008u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *ModelProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000008u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *ModelProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.ModelProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void ModelProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.doc_string) +} + +// optional .onnx.GraphProto graph = 7; +inline bool ModelProto::_internal_has_graph() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + PROTOBUF_ASSUME(!value || graph_ != nullptr); + return value; +} +inline bool ModelProto::has_graph() const { return _internal_has_graph(); } +inline void ModelProto::clear_graph() { + if (graph_ != nullptr) + graph_->Clear(); + _has_bits_[0] &= ~0x00000010u; +} +inline const ::onnx::GraphProto &ModelProto::_internal_graph() const { + const ::onnx::GraphProto *p = graph_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_GraphProto_default_instance_); +} +inline const ::onnx::GraphProto &ModelProto::graph() const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.graph) + return _internal_graph(); +} +inline void +ModelProto::unsafe_arena_set_allocated_graph(::onnx::GraphProto *graph) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(graph_); + } + graph_ = graph; + if (graph) { + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.ModelProto.graph) +} +inline ::onnx::GraphProto *ModelProto::release_graph() { + _has_bits_[0] &= ~0x00000010u; + ::onnx::GraphProto *temp = graph_; + graph_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::GraphProto *ModelProto::unsafe_arena_release_graph() { + // @@protoc_insertion_point(field_release:onnx.ModelProto.graph) + _has_bits_[0] &= ~0x00000010u; + ::onnx::GraphProto *temp = graph_; + graph_ = nullptr; + return temp; +} +inline ::onnx::GraphProto *ModelProto::_internal_mutable_graph() { + _has_bits_[0] |= 0x00000010u; + if (graph_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::GraphProto>(GetArenaForAllocation()); + graph_ = p; + } + return graph_; +} +inline ::onnx::GraphProto *ModelProto::mutable_graph() { + ::onnx::GraphProto *_msg = _internal_mutable_graph(); + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.graph) + return _msg; +} +inline void ModelProto::set_allocated_graph(::onnx::GraphProto *graph) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete graph_; + } + if (graph) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(graph); + if (message_arena != submessage_arena) { + graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, graph, submessage_arena); + } + _has_bits_[0] |= 0x00000010u; + } else { + _has_bits_[0] &= ~0x00000010u; + } + graph_ = graph; + // @@protoc_insertion_point(field_set_allocated:onnx.ModelProto.graph) +} + +// repeated .onnx.StringStringEntryProto metadata_props = 14; +inline int ModelProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int ModelProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void ModelProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +ModelProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *ModelProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +ModelProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +ModelProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +ModelProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *ModelProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.ModelProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +ModelProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.ModelProto.metadata_props) + return metadata_props_; +} + +// repeated .onnx.TrainingInfoProto training_info = 20; +inline int ModelProto::_internal_training_info_size() const { + return training_info_.size(); +} +inline int ModelProto::training_info_size() const { + return _internal_training_info_size(); +} +inline void ModelProto::clear_training_info() { training_info_.Clear(); } +inline ::onnx::TrainingInfoProto *ModelProto::mutable_training_info(int index) { + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.training_info) + return training_info_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TrainingInfoProto> * +ModelProto::mutable_training_info() { + // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.training_info) + return &training_info_; +} +inline const ::onnx::TrainingInfoProto & +ModelProto::_internal_training_info(int index) const { + return training_info_.Get(index); +} +inline const ::onnx::TrainingInfoProto & +ModelProto::training_info(int index) const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.training_info) + return _internal_training_info(index); +} +inline ::onnx::TrainingInfoProto *ModelProto::_internal_add_training_info() { + return training_info_.Add(); +} +inline ::onnx::TrainingInfoProto *ModelProto::add_training_info() { + ::onnx::TrainingInfoProto *_add = _internal_add_training_info(); + // @@protoc_insertion_point(field_add:onnx.ModelProto.training_info) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::TrainingInfoProto> & +ModelProto::training_info() const { + // @@protoc_insertion_point(field_list:onnx.ModelProto.training_info) + return training_info_; +} + +// repeated .onnx.FunctionProto functions = 25; +inline int ModelProto::_internal_functions_size() const { + return functions_.size(); +} +inline int ModelProto::functions_size() const { + return _internal_functions_size(); +} +inline void ModelProto::clear_functions() { functions_.Clear(); } +inline ::onnx::FunctionProto *ModelProto::mutable_functions(int index) { + // @@protoc_insertion_point(field_mutable:onnx.ModelProto.functions) + return functions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::FunctionProto> * +ModelProto::mutable_functions() { + // @@protoc_insertion_point(field_mutable_list:onnx.ModelProto.functions) + return &functions_; +} +inline const ::onnx::FunctionProto & +ModelProto::_internal_functions(int index) const { + return functions_.Get(index); +} +inline const ::onnx::FunctionProto &ModelProto::functions(int index) const { + // @@protoc_insertion_point(field_get:onnx.ModelProto.functions) + return _internal_functions(index); +} +inline ::onnx::FunctionProto *ModelProto::_internal_add_functions() { + return functions_.Add(); +} +inline ::onnx::FunctionProto *ModelProto::add_functions() { + ::onnx::FunctionProto *_add = _internal_add_functions(); + // @@protoc_insertion_point(field_add:onnx.ModelProto.functions) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::FunctionProto> & +ModelProto::functions() const { + // @@protoc_insertion_point(field_list:onnx.ModelProto.functions) + return functions_; +} + +// ------------------------------------------------------------------- + +// StringStringEntryProto + +// optional string key = 1; +inline bool StringStringEntryProto::_internal_has_key() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool StringStringEntryProto::has_key() const { + return _internal_has_key(); +} +inline void StringStringEntryProto::clear_key() { + key_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &StringStringEntryProto::key() const { + // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.key) + return _internal_key(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +StringStringEntryProto::set_key(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + key_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.key) +} +inline std::string *StringStringEntryProto::mutable_key() { + std::string *_s = _internal_mutable_key(); + // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.key) + return _s; +} +inline const std::string &StringStringEntryProto::_internal_key() const { + return key_.Get(); +} +inline void +StringStringEntryProto::_internal_set_key(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + key_.Set(value, GetArenaForAllocation()); +} +inline std::string *StringStringEntryProto::_internal_mutable_key() { + _has_bits_[0] |= 0x00000001u; + return key_.Mutable(GetArenaForAllocation()); +} +inline std::string *StringStringEntryProto::release_key() { + // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.key) + if (!_internal_has_key()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = key_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (key_.IsDefault()) { + key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StringStringEntryProto::set_allocated_key(std::string *key) { + if (key != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + key_.SetAllocated(key, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (key_.IsDefault()) { + key_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.key) +} + +// optional string value = 2; +inline bool StringStringEntryProto::_internal_has_value() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool StringStringEntryProto::has_value() const { + return _internal_has_value(); +} +inline void StringStringEntryProto::clear_value() { + value_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &StringStringEntryProto::value() const { + // @@protoc_insertion_point(field_get:onnx.StringStringEntryProto.value) + return _internal_value(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +StringStringEntryProto::set_value(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000002u; + value_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.StringStringEntryProto.value) +} +inline std::string *StringStringEntryProto::mutable_value() { + std::string *_s = _internal_mutable_value(); + // @@protoc_insertion_point(field_mutable:onnx.StringStringEntryProto.value) + return _s; +} +inline const std::string &StringStringEntryProto::_internal_value() const { + return value_.Get(); +} +inline void +StringStringEntryProto::_internal_set_value(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + value_.Set(value, GetArenaForAllocation()); +} +inline std::string *StringStringEntryProto::_internal_mutable_value() { + _has_bits_[0] |= 0x00000002u; + return value_.Mutable(GetArenaForAllocation()); +} +inline std::string *StringStringEntryProto::release_value() { + // @@protoc_insertion_point(field_release:onnx.StringStringEntryProto.value) + if (!_internal_has_value()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = value_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (value_.IsDefault()) { + value_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void StringStringEntryProto::set_allocated_value(std::string *value) { + if (value != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + value_.SetAllocated(value, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (value_.IsDefault()) { + value_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.StringStringEntryProto.value) +} + +// ------------------------------------------------------------------- + +// TensorAnnotation + +// optional string tensor_name = 1; +inline bool TensorAnnotation::_internal_has_tensor_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TensorAnnotation::has_tensor_name() const { + return _internal_has_tensor_name(); +} +inline void TensorAnnotation::clear_tensor_name() { + tensor_name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &TensorAnnotation::tensor_name() const { + // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.tensor_name) + return _internal_tensor_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +TensorAnnotation::set_tensor_name(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + tensor_name_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorAnnotation.tensor_name) +} +inline std::string *TensorAnnotation::mutable_tensor_name() { + std::string *_s = _internal_mutable_tensor_name(); + // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.tensor_name) + return _s; +} +inline const std::string &TensorAnnotation::_internal_tensor_name() const { + return tensor_name_.Get(); +} +inline void +TensorAnnotation::_internal_set_tensor_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + tensor_name_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorAnnotation::_internal_mutable_tensor_name() { + _has_bits_[0] |= 0x00000001u; + return tensor_name_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorAnnotation::release_tensor_name() { + // @@protoc_insertion_point(field_release:onnx.TensorAnnotation.tensor_name) + if (!_internal_has_tensor_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = tensor_name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (tensor_name_.IsDefault()) { + tensor_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void +TensorAnnotation::set_allocated_tensor_name(std::string *tensor_name) { + if (tensor_name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + tensor_name_.SetAllocated(tensor_name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (tensor_name_.IsDefault()) { + tensor_name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.TensorAnnotation.tensor_name) +} + +// repeated .onnx.StringStringEntryProto quant_parameter_tensor_names = 2; +inline int +TensorAnnotation::_internal_quant_parameter_tensor_names_size() const { + return quant_parameter_tensor_names_.size(); +} +inline int TensorAnnotation::quant_parameter_tensor_names_size() const { + return _internal_quant_parameter_tensor_names_size(); +} +inline void TensorAnnotation::clear_quant_parameter_tensor_names() { + quant_parameter_tensor_names_.Clear(); +} +inline ::onnx::StringStringEntryProto * +TensorAnnotation::mutable_quant_parameter_tensor_names(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TensorAnnotation.quant_parameter_tensor_names) + return quant_parameter_tensor_names_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *TensorAnnotation::mutable_quant_parameter_tensor_names() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorAnnotation.quant_parameter_tensor_names) + return &quant_parameter_tensor_names_; +} +inline const ::onnx::StringStringEntryProto & +TensorAnnotation::_internal_quant_parameter_tensor_names(int index) const { + return quant_parameter_tensor_names_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +TensorAnnotation::quant_parameter_tensor_names(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorAnnotation.quant_parameter_tensor_names) + return _internal_quant_parameter_tensor_names(index); +} +inline ::onnx::StringStringEntryProto * +TensorAnnotation::_internal_add_quant_parameter_tensor_names() { + return quant_parameter_tensor_names_.Add(); +} +inline ::onnx::StringStringEntryProto * +TensorAnnotation::add_quant_parameter_tensor_names() { + ::onnx::StringStringEntryProto *_add = + _internal_add_quant_parameter_tensor_names(); + // @@protoc_insertion_point(field_add:onnx.TensorAnnotation.quant_parameter_tensor_names) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +TensorAnnotation::quant_parameter_tensor_names() const { + // @@protoc_insertion_point(field_list:onnx.TensorAnnotation.quant_parameter_tensor_names) + return quant_parameter_tensor_names_; +} + +// ------------------------------------------------------------------- + +// GraphProto + +// repeated .onnx.NodeProto node = 1; +inline int GraphProto::_internal_node_size() const { return node_.size(); } +inline int GraphProto::node_size() const { return _internal_node_size(); } +inline void GraphProto::clear_node() { node_.Clear(); } +inline ::onnx::NodeProto *GraphProto::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.node) + return node_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> * +GraphProto::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.node) + return &node_; +} +inline const ::onnx::NodeProto &GraphProto::_internal_node(int index) const { + return node_.Get(index); +} +inline const ::onnx::NodeProto &GraphProto::node(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.node) + return _internal_node(index); +} +inline ::onnx::NodeProto *GraphProto::_internal_add_node() { + return node_.Add(); +} +inline ::onnx::NodeProto *GraphProto::add_node() { + ::onnx::NodeProto *_add = _internal_add_node(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.node) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> & +GraphProto::node() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.node) + return node_; +} + +// optional string name = 2; +inline bool GraphProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool GraphProto::has_name() const { return _internal_has_name(); } +inline void GraphProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &GraphProto::name() const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.GraphProto.name) +} +inline std::string *GraphProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.name) + return _s; +} +inline const std::string &GraphProto::_internal_name() const { + return name_.Get(); +} +inline void GraphProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *GraphProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *GraphProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.GraphProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void GraphProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.name) +} + +// repeated .onnx.TensorProto initializer = 5; +inline int GraphProto::_internal_initializer_size() const { + return initializer_.size(); +} +inline int GraphProto::initializer_size() const { + return _internal_initializer_size(); +} +inline void GraphProto::clear_initializer() { initializer_.Clear(); } +inline ::onnx::TensorProto *GraphProto::mutable_initializer(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.initializer) + return initializer_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> * +GraphProto::mutable_initializer() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.initializer) + return &initializer_; +} +inline const ::onnx::TensorProto & +GraphProto::_internal_initializer(int index) const { + return initializer_.Get(index); +} +inline const ::onnx::TensorProto &GraphProto::initializer(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.initializer) + return _internal_initializer(index); +} +inline ::onnx::TensorProto *GraphProto::_internal_add_initializer() { + return initializer_.Add(); +} +inline ::onnx::TensorProto *GraphProto::add_initializer() { + ::onnx::TensorProto *_add = _internal_add_initializer(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.initializer) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorProto> & +GraphProto::initializer() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.initializer) + return initializer_; +} + +// repeated .onnx.SparseTensorProto sparse_initializer = 15; +inline int GraphProto::_internal_sparse_initializer_size() const { + return sparse_initializer_.size(); +} +inline int GraphProto::sparse_initializer_size() const { + return _internal_sparse_initializer_size(); +} +inline void GraphProto::clear_sparse_initializer() { + sparse_initializer_.Clear(); +} +inline ::onnx::SparseTensorProto * +GraphProto::mutable_sparse_initializer(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.sparse_initializer) + return sparse_initializer_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::SparseTensorProto> * +GraphProto::mutable_sparse_initializer() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.sparse_initializer) + return &sparse_initializer_; +} +inline const ::onnx::SparseTensorProto & +GraphProto::_internal_sparse_initializer(int index) const { + return sparse_initializer_.Get(index); +} +inline const ::onnx::SparseTensorProto & +GraphProto::sparse_initializer(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.sparse_initializer) + return _internal_sparse_initializer(index); +} +inline ::onnx::SparseTensorProto * +GraphProto::_internal_add_sparse_initializer() { + return sparse_initializer_.Add(); +} +inline ::onnx::SparseTensorProto *GraphProto::add_sparse_initializer() { + ::onnx::SparseTensorProto *_add = _internal_add_sparse_initializer(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.sparse_initializer) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::SparseTensorProto> & +GraphProto::sparse_initializer() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.sparse_initializer) + return sparse_initializer_; +} + +// optional string doc_string = 10; +inline bool GraphProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool GraphProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void GraphProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &GraphProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void GraphProto::set_doc_string(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.GraphProto.doc_string) +} +inline std::string *GraphProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.doc_string) + return _s; +} +inline const std::string &GraphProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void GraphProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *GraphProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000002u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *GraphProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.GraphProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void GraphProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.GraphProto.doc_string) +} + +// repeated .onnx.ValueInfoProto input = 11; +inline int GraphProto::_internal_input_size() const { return input_.size(); } +inline int GraphProto::input_size() const { return _internal_input_size(); } +inline void GraphProto::clear_input() { input_.Clear(); } +inline ::onnx::ValueInfoProto *GraphProto::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.input) + return input_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * +GraphProto::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.input) + return &input_; +} +inline const ::onnx::ValueInfoProto & +GraphProto::_internal_input(int index) const { + return input_.Get(index); +} +inline const ::onnx::ValueInfoProto &GraphProto::input(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.input) + return _internal_input(index); +} +inline ::onnx::ValueInfoProto *GraphProto::_internal_add_input() { + return input_.Add(); +} +inline ::onnx::ValueInfoProto *GraphProto::add_input() { + ::onnx::ValueInfoProto *_add = _internal_add_input(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.input) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & +GraphProto::input() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.input) + return input_; +} + +// repeated .onnx.ValueInfoProto output = 12; +inline int GraphProto::_internal_output_size() const { return output_.size(); } +inline int GraphProto::output_size() const { return _internal_output_size(); } +inline void GraphProto::clear_output() { output_.Clear(); } +inline ::onnx::ValueInfoProto *GraphProto::mutable_output(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.output) + return output_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * +GraphProto::mutable_output() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.output) + return &output_; +} +inline const ::onnx::ValueInfoProto & +GraphProto::_internal_output(int index) const { + return output_.Get(index); +} +inline const ::onnx::ValueInfoProto &GraphProto::output(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.output) + return _internal_output(index); +} +inline ::onnx::ValueInfoProto *GraphProto::_internal_add_output() { + return output_.Add(); +} +inline ::onnx::ValueInfoProto *GraphProto::add_output() { + ::onnx::ValueInfoProto *_add = _internal_add_output(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.output) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & +GraphProto::output() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.output) + return output_; +} + +// repeated .onnx.ValueInfoProto value_info = 13; +inline int GraphProto::_internal_value_info_size() const { + return value_info_.size(); +} +inline int GraphProto::value_info_size() const { + return _internal_value_info_size(); +} +inline void GraphProto::clear_value_info() { value_info_.Clear(); } +inline ::onnx::ValueInfoProto *GraphProto::mutable_value_info(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.value_info) + return value_info_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * +GraphProto::mutable_value_info() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.value_info) + return &value_info_; +} +inline const ::onnx::ValueInfoProto & +GraphProto::_internal_value_info(int index) const { + return value_info_.Get(index); +} +inline const ::onnx::ValueInfoProto &GraphProto::value_info(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.value_info) + return _internal_value_info(index); +} +inline ::onnx::ValueInfoProto *GraphProto::_internal_add_value_info() { + return value_info_.Add(); +} +inline ::onnx::ValueInfoProto *GraphProto::add_value_info() { + ::onnx::ValueInfoProto *_add = _internal_add_value_info(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.value_info) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & +GraphProto::value_info() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.value_info) + return value_info_; +} + +// repeated .onnx.TensorAnnotation quantization_annotation = 14; +inline int GraphProto::_internal_quantization_annotation_size() const { + return quantization_annotation_.size(); +} +inline int GraphProto::quantization_annotation_size() const { + return _internal_quantization_annotation_size(); +} +inline void GraphProto::clear_quantization_annotation() { + quantization_annotation_.Clear(); +} +inline ::onnx::TensorAnnotation * +GraphProto::mutable_quantization_annotation(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.quantization_annotation) + return quantization_annotation_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorAnnotation> * +GraphProto::mutable_quantization_annotation() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.quantization_annotation) + return &quantization_annotation_; +} +inline const ::onnx::TensorAnnotation & +GraphProto::_internal_quantization_annotation(int index) const { + return quantization_annotation_.Get(index); +} +inline const ::onnx::TensorAnnotation & +GraphProto::quantization_annotation(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.quantization_annotation) + return _internal_quantization_annotation(index); +} +inline ::onnx::TensorAnnotation * +GraphProto::_internal_add_quantization_annotation() { + return quantization_annotation_.Add(); +} +inline ::onnx::TensorAnnotation *GraphProto::add_quantization_annotation() { + ::onnx::TensorAnnotation *_add = _internal_add_quantization_annotation(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.quantization_annotation) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::TensorAnnotation> + &GraphProto::quantization_annotation() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.quantization_annotation) + return quantization_annotation_; +} + +// repeated .onnx.StringStringEntryProto metadata_props = 16; +inline int GraphProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int GraphProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void GraphProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +GraphProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.GraphProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *GraphProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.GraphProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +GraphProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +GraphProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.GraphProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +GraphProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *GraphProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.GraphProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +GraphProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.GraphProto.metadata_props) + return metadata_props_; +} + +// ------------------------------------------------------------------- + +// TensorProto_Segment + +// optional int64 begin = 1; +inline bool TensorProto_Segment::_internal_has_begin() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TensorProto_Segment::has_begin() const { + return _internal_has_begin(); +} +inline void TensorProto_Segment::clear_begin() { + begin_ = int64_t{0}; + _has_bits_[0] &= ~0x00000001u; +} +inline int64_t TensorProto_Segment::_internal_begin() const { return begin_; } +inline int64_t TensorProto_Segment::begin() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.begin) + return _internal_begin(); +} +inline void TensorProto_Segment::_internal_set_begin(int64_t value) { + _has_bits_[0] |= 0x00000001u; + begin_ = value; +} +inline void TensorProto_Segment::set_begin(int64_t value) { + _internal_set_begin(value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.begin) +} + +// optional int64 end = 2; +inline bool TensorProto_Segment::_internal_has_end() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TensorProto_Segment::has_end() const { return _internal_has_end(); } +inline void TensorProto_Segment::clear_end() { + end_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t TensorProto_Segment::_internal_end() const { return end_; } +inline int64_t TensorProto_Segment::end() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.Segment.end) + return _internal_end(); +} +inline void TensorProto_Segment::_internal_set_end(int64_t value) { + _has_bits_[0] |= 0x00000002u; + end_ = value; +} +inline void TensorProto_Segment::set_end(int64_t value) { + _internal_set_end(value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.Segment.end) +} + +// ------------------------------------------------------------------- + +// TensorProto + +// repeated int64 dims = 1; +inline int TensorProto::_internal_dims_size() const { return dims_.size(); } +inline int TensorProto::dims_size() const { return _internal_dims_size(); } +inline void TensorProto::clear_dims() { dims_.Clear(); } +inline int64_t TensorProto::_internal_dims(int index) const { + return dims_.Get(index); +} +inline int64_t TensorProto::dims(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.dims) + return _internal_dims(index); +} +inline void TensorProto::set_dims(int index, int64_t value) { + dims_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.dims) +} +inline void TensorProto::_internal_add_dims(int64_t value) { dims_.Add(value); } +inline void TensorProto::add_dims(int64_t value) { + _internal_add_dims(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.dims) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_dims() const { + return dims_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::dims() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.dims) + return _internal_dims(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_dims() { + return &dims_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_dims() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.dims) + return _internal_mutable_dims(); +} + +// optional int32 data_type = 2; +inline bool TensorProto::_internal_has_data_type() const { + bool value = (_has_bits_[0] & 0x00000010u) != 0; + return value; +} +inline bool TensorProto::has_data_type() const { + return _internal_has_data_type(); +} +inline void TensorProto::clear_data_type() { + data_type_ = 0; + _has_bits_[0] &= ~0x00000010u; +} +inline int32_t TensorProto::_internal_data_type() const { return data_type_; } +inline int32_t TensorProto::data_type() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.data_type) + return _internal_data_type(); +} +inline void TensorProto::_internal_set_data_type(int32_t value) { + _has_bits_[0] |= 0x00000010u; + data_type_ = value; +} +inline void TensorProto::set_data_type(int32_t value) { + _internal_set_data_type(value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.data_type) +} + +// optional .onnx.TensorProto.Segment segment = 3; +inline bool TensorProto::_internal_has_segment() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + PROTOBUF_ASSUME(!value || segment_ != nullptr); + return value; +} +inline bool TensorProto::has_segment() const { return _internal_has_segment(); } +inline void TensorProto::clear_segment() { + if (segment_ != nullptr) + segment_->Clear(); + _has_bits_[0] &= ~0x00000008u; +} +inline const ::onnx::TensorProto_Segment & +TensorProto::_internal_segment() const { + const ::onnx::TensorProto_Segment *p = segment_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorProto_Segment_default_instance_); +} +inline const ::onnx::TensorProto_Segment &TensorProto::segment() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.segment) + return _internal_segment(); +} +inline void TensorProto::unsafe_arena_set_allocated_segment( + ::onnx::TensorProto_Segment *segment) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(segment_); + } + segment_ = segment; + if (segment) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TensorProto.segment) +} +inline ::onnx::TensorProto_Segment *TensorProto::release_segment() { + _has_bits_[0] &= ~0x00000008u; + ::onnx::TensorProto_Segment *temp = segment_; + segment_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorProto_Segment * +TensorProto::unsafe_arena_release_segment() { + // @@protoc_insertion_point(field_release:onnx.TensorProto.segment) + _has_bits_[0] &= ~0x00000008u; + ::onnx::TensorProto_Segment *temp = segment_; + segment_ = nullptr; + return temp; +} +inline ::onnx::TensorProto_Segment *TensorProto::_internal_mutable_segment() { + _has_bits_[0] |= 0x00000008u; + if (segment_ == nullptr) { + auto *p = + CreateMaybeMessage<::onnx::TensorProto_Segment>(GetArenaForAllocation()); + segment_ = p; + } + return segment_; +} +inline ::onnx::TensorProto_Segment *TensorProto::mutable_segment() { + ::onnx::TensorProto_Segment *_msg = _internal_mutable_segment(); + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.segment) + return _msg; +} +inline void +TensorProto::set_allocated_segment(::onnx::TensorProto_Segment *segment) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete segment_; + } + if (segment) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(segment); + if (message_arena != submessage_arena) { + segment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, segment, submessage_arena); + } + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + segment_ = segment; + // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.segment) +} + +// repeated float float_data = 4 [packed = true]; +inline int TensorProto::_internal_float_data_size() const { + return float_data_.size(); +} +inline int TensorProto::float_data_size() const { + return _internal_float_data_size(); +} +inline void TensorProto::clear_float_data() { float_data_.Clear(); } +inline float TensorProto::_internal_float_data(int index) const { + return float_data_.Get(index); +} +inline float TensorProto::float_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.float_data) + return _internal_float_data(index); +} +inline void TensorProto::set_float_data(int index, float value) { + float_data_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.float_data) +} +inline void TensorProto::_internal_add_float_data(float value) { + float_data_.Add(value); +} +inline void TensorProto::add_float_data(float value) { + _internal_add_float_data(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.float_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_float_data() const { + return float_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::float_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.float_data) + return _internal_float_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_float_data() { + return &float_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_float_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.float_data) + return _internal_mutable_float_data(); +} + +// repeated int32 int32_data = 5 [packed = true]; +inline int TensorProto::_internal_int32_data_size() const { + return int32_data_.size(); +} +inline int TensorProto::int32_data_size() const { + return _internal_int32_data_size(); +} +inline void TensorProto::clear_int32_data() { int32_data_.Clear(); } +inline int32_t TensorProto::_internal_int32_data(int index) const { + return int32_data_.Get(index); +} +inline int32_t TensorProto::int32_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.int32_data) + return _internal_int32_data(index); +} +inline void TensorProto::set_int32_data(int index, int32_t value) { + int32_data_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.int32_data) +} +inline void TensorProto::_internal_add_int32_data(int32_t value) { + int32_data_.Add(value); +} +inline void TensorProto::add_int32_data(int32_t value) { + _internal_add_int32_data(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.int32_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_int32_data() const { + return int32_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::int32_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.int32_data) + return _internal_int32_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_int32_data() { + return &int32_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_int32_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int32_data) + return _internal_mutable_int32_data(); +} + +// repeated bytes string_data = 6; +inline int TensorProto::_internal_string_data_size() const { + return string_data_.size(); +} +inline int TensorProto::string_data_size() const { + return _internal_string_data_size(); +} +inline void TensorProto::clear_string_data() { string_data_.Clear(); } +inline std::string *TensorProto::add_string_data() { + std::string *_s = _internal_add_string_data(); + // @@protoc_insertion_point(field_add_mutable:onnx.TensorProto.string_data) + return _s; +} +inline const std::string &TensorProto::_internal_string_data(int index) const { + return string_data_.Get(index); +} +inline const std::string &TensorProto::string_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.string_data) + return _internal_string_data(index); +} +inline std::string *TensorProto::mutable_string_data(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.string_data) + return string_data_.Mutable(index); +} +inline void TensorProto::set_string_data(int index, const std::string &value) { + string_data_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data) +} +inline void TensorProto::set_string_data(int index, std::string &&value) { + string_data_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.TensorProto.string_data) +} +inline void TensorProto::set_string_data(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + string_data_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char: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:onnx.TensorProto.string_data) +} +inline std::string *TensorProto::_internal_add_string_data() { + return string_data_.Add(); +} +inline void TensorProto::add_string_data(const std::string &value) { + string_data_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data) +} +inline void TensorProto::add_string_data(std::string &&value) { + string_data_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.TensorProto.string_data) +} +inline void TensorProto::add_string_data(const char *value) { + GOOGLE_DCHECK(value != nullptr); + string_data_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char: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:onnx.TensorProto.string_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +TensorProto::string_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.string_data) + return string_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +TensorProto::mutable_string_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.string_data) + return &string_data_; +} + +// repeated int64 int64_data = 7 [packed = true]; +inline int TensorProto::_internal_int64_data_size() const { + return int64_data_.size(); +} +inline int TensorProto::int64_data_size() const { + return _internal_int64_data_size(); +} +inline void TensorProto::clear_int64_data() { int64_data_.Clear(); } +inline int64_t TensorProto::_internal_int64_data(int index) const { + return int64_data_.Get(index); +} +inline int64_t TensorProto::int64_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.int64_data) + return _internal_int64_data(index); +} +inline void TensorProto::set_int64_data(int index, int64_t value) { + int64_data_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.int64_data) +} +inline void TensorProto::_internal_add_int64_data(int64_t value) { + int64_data_.Add(value); +} +inline void TensorProto::add_int64_data(int64_t value) { + _internal_add_int64_data(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.int64_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_int64_data() const { + return int64_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::int64_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.int64_data) + return _internal_int64_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_int64_data() { + return &int64_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_int64_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.int64_data) + return _internal_mutable_int64_data(); +} + +// optional string name = 8; +inline bool TensorProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TensorProto::has_name() const { return _internal_has_name(); } +inline void TensorProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &TensorProto::name() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorProto.name) +} +inline std::string *TensorProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.name) + return _s; +} +inline const std::string &TensorProto::_internal_name() const { + return name_.Get(); +} +inline void TensorProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.TensorProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TensorProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.name) +} + +// optional string doc_string = 12; +inline bool TensorProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool TensorProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void TensorProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string &TensorProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_doc_string(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorProto.doc_string) +} +inline std::string *TensorProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.doc_string) + return _s; +} +inline const std::string &TensorProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void TensorProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000004u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000004u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.TensorProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TensorProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.doc_string) +} + +// optional bytes raw_data = 9; +inline bool TensorProto::_internal_has_raw_data() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TensorProto::has_raw_data() const { + return _internal_has_raw_data(); +} +inline void TensorProto::clear_raw_data() { + raw_data_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &TensorProto::raw_data() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.raw_data) + return _internal_raw_data(); +} +template +inline PROTOBUF_ALWAYS_INLINE void TensorProto::set_raw_data(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000002u; + raw_data_.SetBytes(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorProto.raw_data) +} +inline std::string *TensorProto::mutable_raw_data() { + std::string *_s = _internal_mutable_raw_data(); + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.raw_data) + return _s; +} +inline const std::string &TensorProto::_internal_raw_data() const { + return raw_data_.Get(); +} +inline void TensorProto::_internal_set_raw_data(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + raw_data_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorProto::_internal_mutable_raw_data() { + _has_bits_[0] |= 0x00000002u; + return raw_data_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorProto::release_raw_data() { + // @@protoc_insertion_point(field_release:onnx.TensorProto.raw_data) + if (!_internal_has_raw_data()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = raw_data_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (raw_data_.IsDefault()) { + raw_data_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TensorProto::set_allocated_raw_data(std::string *raw_data) { + if (raw_data != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + raw_data_.SetAllocated(raw_data, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (raw_data_.IsDefault()) { + raw_data_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.TensorProto.raw_data) +} + +// repeated .onnx.StringStringEntryProto external_data = 13; +inline int TensorProto::_internal_external_data_size() const { + return external_data_.size(); +} +inline int TensorProto::external_data_size() const { + return _internal_external_data_size(); +} +inline void TensorProto::clear_external_data() { external_data_.Clear(); } +inline ::onnx::StringStringEntryProto * +TensorProto::mutable_external_data(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.external_data) + return external_data_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *TensorProto::mutable_external_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.external_data) + return &external_data_; +} +inline const ::onnx::StringStringEntryProto & +TensorProto::_internal_external_data(int index) const { + return external_data_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +TensorProto::external_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.external_data) + return _internal_external_data(index); +} +inline ::onnx::StringStringEntryProto * +TensorProto::_internal_add_external_data() { + return external_data_.Add(); +} +inline ::onnx::StringStringEntryProto *TensorProto::add_external_data() { + ::onnx::StringStringEntryProto *_add = _internal_add_external_data(); + // @@protoc_insertion_point(field_add:onnx.TensorProto.external_data) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +TensorProto::external_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.external_data) + return external_data_; +} + +// optional .onnx.TensorProto.DataLocation data_location = 14; +inline bool TensorProto::_internal_has_data_location() const { + bool value = (_has_bits_[0] & 0x00000020u) != 0; + return value; +} +inline bool TensorProto::has_data_location() const { + return _internal_has_data_location(); +} +inline void TensorProto::clear_data_location() { + data_location_ = 0; + _has_bits_[0] &= ~0x00000020u; +} +inline ::onnx::TensorProto_DataLocation +TensorProto::_internal_data_location() const { + return static_cast<::onnx::TensorProto_DataLocation>(data_location_); +} +inline ::onnx::TensorProto_DataLocation TensorProto::data_location() const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.data_location) + return _internal_data_location(); +} +inline void TensorProto::_internal_set_data_location( + ::onnx::TensorProto_DataLocation value) { + assert(::onnx::TensorProto_DataLocation_IsValid(value)); + _has_bits_[0] |= 0x00000020u; + data_location_ = value; +} +inline void +TensorProto::set_data_location(::onnx::TensorProto_DataLocation value) { + _internal_set_data_location(value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.data_location) +} + +// repeated double double_data = 10 [packed = true]; +inline int TensorProto::_internal_double_data_size() const { + return double_data_.size(); +} +inline int TensorProto::double_data_size() const { + return _internal_double_data_size(); +} +inline void TensorProto::clear_double_data() { double_data_.Clear(); } +inline double TensorProto::_internal_double_data(int index) const { + return double_data_.Get(index); +} +inline double TensorProto::double_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.double_data) + return _internal_double_data(index); +} +inline void TensorProto::set_double_data(int index, double value) { + double_data_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.double_data) +} +inline void TensorProto::_internal_add_double_data(double value) { + double_data_.Add(value); +} +inline void TensorProto::add_double_data(double value) { + _internal_add_double_data(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.double_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_double_data() const { + return double_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::double_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.double_data) + return _internal_double_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_double_data() { + return &double_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_double_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.double_data) + return _internal_mutable_double_data(); +} + +// repeated uint64 uint64_data = 11 [packed = true]; +inline int TensorProto::_internal_uint64_data_size() const { + return uint64_data_.size(); +} +inline int TensorProto::uint64_data_size() const { + return _internal_uint64_data_size(); +} +inline void TensorProto::clear_uint64_data() { uint64_data_.Clear(); } +inline uint64_t TensorProto::_internal_uint64_data(int index) const { + return uint64_data_.Get(index); +} +inline uint64_t TensorProto::uint64_data(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.uint64_data) + return _internal_uint64_data(index); +} +inline void TensorProto::set_uint64_data(int index, uint64_t value) { + uint64_data_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.TensorProto.uint64_data) +} +inline void TensorProto::_internal_add_uint64_data(uint64_t value) { + uint64_data_.Add(value); +} +inline void TensorProto::add_uint64_data(uint64_t value) { + _internal_add_uint64_data(value); + // @@protoc_insertion_point(field_add:onnx.TensorProto.uint64_data) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::_internal_uint64_data() const { + return uint64_data_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +TensorProto::uint64_data() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.uint64_data) + return _internal_uint64_data(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::_internal_mutable_uint64_data() { + return &uint64_data_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +TensorProto::mutable_uint64_data() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.uint64_data) + return _internal_mutable_uint64_data(); +} + +// repeated .onnx.StringStringEntryProto metadata_props = 16; +inline int TensorProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int TensorProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void TensorProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +TensorProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TensorProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *TensorProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +TensorProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +TensorProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +TensorProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *TensorProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.TensorProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +TensorProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.TensorProto.metadata_props) + return metadata_props_; +} + +// ------------------------------------------------------------------- + +// SparseTensorProto + +// optional .onnx.TensorProto values = 1; +inline bool SparseTensorProto::_internal_has_values() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || values_ != nullptr); + return value; +} +inline bool SparseTensorProto::has_values() const { + return _internal_has_values(); +} +inline void SparseTensorProto::clear_values() { + if (values_ != nullptr) + values_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TensorProto &SparseTensorProto::_internal_values() const { + const ::onnx::TensorProto *p = values_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorProto_default_instance_); +} +inline const ::onnx::TensorProto &SparseTensorProto::values() const { + // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.values) + return _internal_values(); +} +inline void SparseTensorProto::unsafe_arena_set_allocated_values( + ::onnx::TensorProto *values) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(values_); + } + values_ = values; + if (values) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.values) +} +inline ::onnx::TensorProto *SparseTensorProto::release_values() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorProto *temp = values_; + values_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorProto *SparseTensorProto::unsafe_arena_release_values() { + // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.values) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorProto *temp = values_; + values_ = nullptr; + return temp; +} +inline ::onnx::TensorProto *SparseTensorProto::_internal_mutable_values() { + _has_bits_[0] |= 0x00000001u; + if (values_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TensorProto>(GetArenaForAllocation()); + values_ = p; + } + return values_; +} +inline ::onnx::TensorProto *SparseTensorProto::mutable_values() { + ::onnx::TensorProto *_msg = _internal_mutable_values(); + // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.values) + return _msg; +} +inline void +SparseTensorProto::set_allocated_values(::onnx::TensorProto *values) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete values_; + } + if (values) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(values); + if (message_arena != submessage_arena) { + values = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, values, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + values_ = values; + // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.values) +} + +// optional .onnx.TensorProto indices = 2; +inline bool SparseTensorProto::_internal_has_indices() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + PROTOBUF_ASSUME(!value || indices_ != nullptr); + return value; +} +inline bool SparseTensorProto::has_indices() const { + return _internal_has_indices(); +} +inline void SparseTensorProto::clear_indices() { + if (indices_ != nullptr) + indices_->Clear(); + _has_bits_[0] &= ~0x00000002u; +} +inline const ::onnx::TensorProto &SparseTensorProto::_internal_indices() const { + const ::onnx::TensorProto *p = indices_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorProto_default_instance_); +} +inline const ::onnx::TensorProto &SparseTensorProto::indices() const { + // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.indices) + return _internal_indices(); +} +inline void SparseTensorProto::unsafe_arena_set_allocated_indices( + ::onnx::TensorProto *indices) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(indices_); + } + indices_ = indices; + if (indices) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.SparseTensorProto.indices) +} +inline ::onnx::TensorProto *SparseTensorProto::release_indices() { + _has_bits_[0] &= ~0x00000002u; + ::onnx::TensorProto *temp = indices_; + indices_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorProto *SparseTensorProto::unsafe_arena_release_indices() { + // @@protoc_insertion_point(field_release:onnx.SparseTensorProto.indices) + _has_bits_[0] &= ~0x00000002u; + ::onnx::TensorProto *temp = indices_; + indices_ = nullptr; + return temp; +} +inline ::onnx::TensorProto *SparseTensorProto::_internal_mutable_indices() { + _has_bits_[0] |= 0x00000002u; + if (indices_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TensorProto>(GetArenaForAllocation()); + indices_ = p; + } + return indices_; +} +inline ::onnx::TensorProto *SparseTensorProto::mutable_indices() { + ::onnx::TensorProto *_msg = _internal_mutable_indices(); + // @@protoc_insertion_point(field_mutable:onnx.SparseTensorProto.indices) + return _msg; +} +inline void +SparseTensorProto::set_allocated_indices(::onnx::TensorProto *indices) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete indices_; + } + if (indices) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(indices); + if (message_arena != submessage_arena) { + indices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, indices, submessage_arena); + } + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + indices_ = indices; + // @@protoc_insertion_point(field_set_allocated:onnx.SparseTensorProto.indices) +} + +// repeated int64 dims = 3; +inline int SparseTensorProto::_internal_dims_size() const { + return dims_.size(); +} +inline int SparseTensorProto::dims_size() const { + return _internal_dims_size(); +} +inline void SparseTensorProto::clear_dims() { dims_.Clear(); } +inline int64_t SparseTensorProto::_internal_dims(int index) const { + return dims_.Get(index); +} +inline int64_t SparseTensorProto::dims(int index) const { + // @@protoc_insertion_point(field_get:onnx.SparseTensorProto.dims) + return _internal_dims(index); +} +inline void SparseTensorProto::set_dims(int index, int64_t value) { + dims_.Set(index, value); + // @@protoc_insertion_point(field_set:onnx.SparseTensorProto.dims) +} +inline void SparseTensorProto::_internal_add_dims(int64_t value) { + dims_.Add(value); +} +inline void SparseTensorProto::add_dims(int64_t value) { + _internal_add_dims(value); + // @@protoc_insertion_point(field_add:onnx.SparseTensorProto.dims) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +SparseTensorProto::_internal_dims() const { + return dims_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField & +SparseTensorProto::dims() const { + // @@protoc_insertion_point(field_list:onnx.SparseTensorProto.dims) + return _internal_dims(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +SparseTensorProto::_internal_mutable_dims() { + return &dims_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField * +SparseTensorProto::mutable_dims() { + // @@protoc_insertion_point(field_mutable_list:onnx.SparseTensorProto.dims) + return _internal_mutable_dims(); +} + +// ------------------------------------------------------------------- + +// TensorShapeProto_Dimension + +// int64 dim_value = 1; +inline bool TensorShapeProto_Dimension::_internal_has_dim_value() const { + return value_case() == kDimValue; +} +inline bool TensorShapeProto_Dimension::has_dim_value() const { + return _internal_has_dim_value(); +} +inline void TensorShapeProto_Dimension::set_has_dim_value() { + _oneof_case_[0] = kDimValue; +} +inline void TensorShapeProto_Dimension::clear_dim_value() { + if (_internal_has_dim_value()) { + value_.dim_value_ = int64_t{0}; + clear_has_value(); + } +} +inline int64_t TensorShapeProto_Dimension::_internal_dim_value() const { + if (_internal_has_dim_value()) { + return value_.dim_value_; + } + return int64_t{0}; +} +inline void TensorShapeProto_Dimension::_internal_set_dim_value(int64_t value) { + if (!_internal_has_dim_value()) { + clear_value(); + set_has_dim_value(); + } + value_.dim_value_ = value; +} +inline int64_t TensorShapeProto_Dimension::dim_value() const { + // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_value) + return _internal_dim_value(); +} +inline void TensorShapeProto_Dimension::set_dim_value(int64_t value) { + _internal_set_dim_value(value); + // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_value) +} + +// string dim_param = 2; +inline bool TensorShapeProto_Dimension::_internal_has_dim_param() const { + return value_case() == kDimParam; +} +inline bool TensorShapeProto_Dimension::has_dim_param() const { + return _internal_has_dim_param(); +} +inline void TensorShapeProto_Dimension::set_has_dim_param() { + _oneof_case_[0] = kDimParam; +} +inline void TensorShapeProto_Dimension::clear_dim_param() { + if (_internal_has_dim_param()) { + value_.dim_param_.Destroy(); + clear_has_value(); + } +} +inline const std::string &TensorShapeProto_Dimension::dim_param() const { + // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.dim_param) + return _internal_dim_param(); +} +template +inline void TensorShapeProto_Dimension::set_dim_param(ArgT0 &&arg0, + ArgT... args) { + if (!_internal_has_dim_param()) { + clear_value(); + set_has_dim_param(); + value_.dim_param_.InitDefault(); + } + value_.dim_param_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.dim_param) +} +inline std::string *TensorShapeProto_Dimension::mutable_dim_param() { + std::string *_s = _internal_mutable_dim_param(); + // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.dim_param) + return _s; +} +inline const std::string & +TensorShapeProto_Dimension::_internal_dim_param() const { + if (_internal_has_dim_param()) { + return value_.dim_param_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void +TensorShapeProto_Dimension::_internal_set_dim_param(const std::string &value) { + if (!_internal_has_dim_param()) { + clear_value(); + set_has_dim_param(); + value_.dim_param_.InitDefault(); + } + value_.dim_param_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorShapeProto_Dimension::_internal_mutable_dim_param() { + if (!_internal_has_dim_param()) { + clear_value(); + set_has_dim_param(); + value_.dim_param_.InitDefault(); + } + return value_.dim_param_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorShapeProto_Dimension::release_dim_param() { + // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.dim_param) + if (_internal_has_dim_param()) { + clear_has_value(); + return value_.dim_param_.Release(); + } else { + return nullptr; + } +} +inline void +TensorShapeProto_Dimension::set_allocated_dim_param(std::string *dim_param) { + if (has_value()) { + clear_value(); + } + if (dim_param != nullptr) { + set_has_dim_param(); + value_.dim_param_.InitAllocated(dim_param, GetArenaForAllocation()); + } + // @@protoc_insertion_point(field_set_allocated:onnx.TensorShapeProto.Dimension.dim_param) +} + +// optional string denotation = 3; +inline bool TensorShapeProto_Dimension::_internal_has_denotation() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TensorShapeProto_Dimension::has_denotation() const { + return _internal_has_denotation(); +} +inline void TensorShapeProto_Dimension::clear_denotation() { + denotation_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &TensorShapeProto_Dimension::denotation() const { + // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.Dimension.denotation) + return _internal_denotation(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +TensorShapeProto_Dimension::set_denotation(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + denotation_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TensorShapeProto.Dimension.denotation) +} +inline std::string *TensorShapeProto_Dimension::mutable_denotation() { + std::string *_s = _internal_mutable_denotation(); + // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.Dimension.denotation) + return _s; +} +inline const std::string & +TensorShapeProto_Dimension::_internal_denotation() const { + return denotation_.Get(); +} +inline void +TensorShapeProto_Dimension::_internal_set_denotation(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + denotation_.Set(value, GetArenaForAllocation()); +} +inline std::string *TensorShapeProto_Dimension::_internal_mutable_denotation() { + _has_bits_[0] |= 0x00000001u; + return denotation_.Mutable(GetArenaForAllocation()); +} +inline std::string *TensorShapeProto_Dimension::release_denotation() { + // @@protoc_insertion_point(field_release:onnx.TensorShapeProto.Dimension.denotation) + if (!_internal_has_denotation()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = denotation_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (denotation_.IsDefault()) { + denotation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void +TensorShapeProto_Dimension::set_allocated_denotation(std::string *denotation) { + if (denotation != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + denotation_.SetAllocated(denotation, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (denotation_.IsDefault()) { + denotation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated: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 .onnx.TensorShapeProto.Dimension dim = 1; +inline int TensorShapeProto::_internal_dim_size() const { return dim_.size(); } +inline int TensorShapeProto::dim_size() const { return _internal_dim_size(); } +inline void TensorShapeProto::clear_dim() { dim_.Clear(); } +inline ::onnx::TensorShapeProto_Dimension * +TensorShapeProto::mutable_dim(int index) { + // @@protoc_insertion_point(field_mutable:onnx.TensorShapeProto.dim) + return dim_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::TensorShapeProto_Dimension> * +TensorShapeProto::mutable_dim() { + // @@protoc_insertion_point(field_mutable_list:onnx.TensorShapeProto.dim) + return &dim_; +} +inline const ::onnx::TensorShapeProto_Dimension & +TensorShapeProto::_internal_dim(int index) const { + return dim_.Get(index); +} +inline const ::onnx::TensorShapeProto_Dimension & +TensorShapeProto::dim(int index) const { + // @@protoc_insertion_point(field_get:onnx.TensorShapeProto.dim) + return _internal_dim(index); +} +inline ::onnx::TensorShapeProto_Dimension * +TensorShapeProto::_internal_add_dim() { + return dim_.Add(); +} +inline ::onnx::TensorShapeProto_Dimension *TensorShapeProto::add_dim() { + ::onnx::TensorShapeProto_Dimension *_add = _internal_add_dim(); + // @@protoc_insertion_point(field_add:onnx.TensorShapeProto.dim) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::TensorShapeProto_Dimension> & +TensorShapeProto::dim() const { + // @@protoc_insertion_point(field_list:onnx.TensorShapeProto.dim) + return dim_; +} + +// ------------------------------------------------------------------- + +// TypeProto_Tensor + +// optional int32 elem_type = 1; +inline bool TypeProto_Tensor::_internal_has_elem_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TypeProto_Tensor::has_elem_type() const { + return _internal_has_elem_type(); +} +inline void TypeProto_Tensor::clear_elem_type() { + elem_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t TypeProto_Tensor::_internal_elem_type() const { + return elem_type_; +} +inline int32_t TypeProto_Tensor::elem_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.elem_type) + return _internal_elem_type(); +} +inline void TypeProto_Tensor::_internal_set_elem_type(int32_t value) { + _has_bits_[0] |= 0x00000002u; + elem_type_ = value; +} +inline void TypeProto_Tensor::set_elem_type(int32_t value) { + _internal_set_elem_type(value); + // @@protoc_insertion_point(field_set:onnx.TypeProto.Tensor.elem_type) +} + +// optional .onnx.TensorShapeProto shape = 2; +inline bool TypeProto_Tensor::_internal_has_shape() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || shape_ != nullptr); + return value; +} +inline bool TypeProto_Tensor::has_shape() const { + return _internal_has_shape(); +} +inline void TypeProto_Tensor::clear_shape() { + if (shape_ != nullptr) + shape_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TensorShapeProto & +TypeProto_Tensor::_internal_shape() const { + const ::onnx::TensorShapeProto *p = shape_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorShapeProto_default_instance_); +} +inline const ::onnx::TensorShapeProto &TypeProto_Tensor::shape() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Tensor.shape) + return _internal_shape(); +} +inline void TypeProto_Tensor::unsafe_arena_set_allocated_shape( + ::onnx::TensorShapeProto *shape) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(shape_); + } + shape_ = shape; + if (shape) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Tensor.shape) +} +inline ::onnx::TensorShapeProto *TypeProto_Tensor::release_shape() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorShapeProto *temp = shape_; + shape_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorShapeProto * +TypeProto_Tensor::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.Tensor.shape) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorShapeProto *temp = shape_; + shape_ = nullptr; + return temp; +} +inline ::onnx::TensorShapeProto *TypeProto_Tensor::_internal_mutable_shape() { + _has_bits_[0] |= 0x00000001u; + if (shape_ == nullptr) { + auto *p = + CreateMaybeMessage<::onnx::TensorShapeProto>(GetArenaForAllocation()); + shape_ = p; + } + return shape_; +} +inline ::onnx::TensorShapeProto *TypeProto_Tensor::mutable_shape() { + ::onnx::TensorShapeProto *_msg = _internal_mutable_shape(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Tensor.shape) + return _msg; +} +inline void +TypeProto_Tensor::set_allocated_shape(::onnx::TensorShapeProto *shape) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete shape_; + } + if (shape) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shape); + if (message_arena != submessage_arena) { + shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shape, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + shape_ = shape; + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Tensor.shape) +} + +// ------------------------------------------------------------------- + +// TypeProto_Sequence + +// optional .onnx.TypeProto elem_type = 1; +inline bool TypeProto_Sequence::_internal_has_elem_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || elem_type_ != nullptr); + return value; +} +inline bool TypeProto_Sequence::has_elem_type() const { + return _internal_has_elem_type(); +} +inline void TypeProto_Sequence::clear_elem_type() { + if (elem_type_ != nullptr) + elem_type_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TypeProto & +TypeProto_Sequence::_internal_elem_type() const { + const ::onnx::TypeProto *p = elem_type_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TypeProto_default_instance_); +} +inline const ::onnx::TypeProto &TypeProto_Sequence::elem_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Sequence.elem_type) + return _internal_elem_type(); +} +inline void TypeProto_Sequence::unsafe_arena_set_allocated_elem_type( + ::onnx::TypeProto *elem_type) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(elem_type_); + } + elem_type_ = elem_type; + if (elem_type) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Sequence.elem_type) +} +inline ::onnx::TypeProto *TypeProto_Sequence::release_elem_type() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = elem_type_; + elem_type_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TypeProto *TypeProto_Sequence::unsafe_arena_release_elem_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.Sequence.elem_type) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = elem_type_; + elem_type_ = nullptr; + return temp; +} +inline ::onnx::TypeProto *TypeProto_Sequence::_internal_mutable_elem_type() { + _has_bits_[0] |= 0x00000001u; + if (elem_type_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TypeProto>(GetArenaForAllocation()); + elem_type_ = p; + } + return elem_type_; +} +inline ::onnx::TypeProto *TypeProto_Sequence::mutable_elem_type() { + ::onnx::TypeProto *_msg = _internal_mutable_elem_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Sequence.elem_type) + return _msg; +} +inline void +TypeProto_Sequence::set_allocated_elem_type(::onnx::TypeProto *elem_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete elem_type_; + } + if (elem_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(elem_type); + if (message_arena != submessage_arena) { + elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, elem_type, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + elem_type_ = elem_type; + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Sequence.elem_type) +} + +// ------------------------------------------------------------------- + +// TypeProto_Map + +// optional int32 key_type = 1; +inline bool TypeProto_Map::_internal_has_key_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TypeProto_Map::has_key_type() const { + return _internal_has_key_type(); +} +inline void TypeProto_Map::clear_key_type() { + key_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t TypeProto_Map::_internal_key_type() const { return key_type_; } +inline int32_t TypeProto_Map::key_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.key_type) + return _internal_key_type(); +} +inline void TypeProto_Map::_internal_set_key_type(int32_t value) { + _has_bits_[0] |= 0x00000002u; + key_type_ = value; +} +inline void TypeProto_Map::set_key_type(int32_t value) { + _internal_set_key_type(value); + // @@protoc_insertion_point(field_set:onnx.TypeProto.Map.key_type) +} + +// optional .onnx.TypeProto value_type = 2; +inline bool TypeProto_Map::_internal_has_value_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || value_type_ != nullptr); + return value; +} +inline bool TypeProto_Map::has_value_type() const { + return _internal_has_value_type(); +} +inline void TypeProto_Map::clear_value_type() { + if (value_type_ != nullptr) + value_type_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TypeProto &TypeProto_Map::_internal_value_type() const { + const ::onnx::TypeProto *p = value_type_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TypeProto_default_instance_); +} +inline const ::onnx::TypeProto &TypeProto_Map::value_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Map.value_type) + return _internal_value_type(); +} +inline void TypeProto_Map::unsafe_arena_set_allocated_value_type( + ::onnx::TypeProto *value_type) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>( + value_type_); + } + value_type_ = value_type; + if (value_type) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Map.value_type) +} +inline ::onnx::TypeProto *TypeProto_Map::release_value_type() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = value_type_; + value_type_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TypeProto *TypeProto_Map::unsafe_arena_release_value_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.Map.value_type) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = value_type_; + value_type_ = nullptr; + return temp; +} +inline ::onnx::TypeProto *TypeProto_Map::_internal_mutable_value_type() { + _has_bits_[0] |= 0x00000001u; + if (value_type_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TypeProto>(GetArenaForAllocation()); + value_type_ = p; + } + return value_type_; +} +inline ::onnx::TypeProto *TypeProto_Map::mutable_value_type() { + ::onnx::TypeProto *_msg = _internal_mutable_value_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Map.value_type) + return _msg; +} +inline void +TypeProto_Map::set_allocated_value_type(::onnx::TypeProto *value_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete value_type_; + } + if (value_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(value_type); + if (message_arena != submessage_arena) { + value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value_type, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + value_type_ = value_type; + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Map.value_type) +} + +// ------------------------------------------------------------------- + +// TypeProto_Optional + +// optional .onnx.TypeProto elem_type = 1; +inline bool TypeProto_Optional::_internal_has_elem_type() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || elem_type_ != nullptr); + return value; +} +inline bool TypeProto_Optional::has_elem_type() const { + return _internal_has_elem_type(); +} +inline void TypeProto_Optional::clear_elem_type() { + if (elem_type_ != nullptr) + elem_type_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TypeProto & +TypeProto_Optional::_internal_elem_type() const { + const ::onnx::TypeProto *p = elem_type_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TypeProto_default_instance_); +} +inline const ::onnx::TypeProto &TypeProto_Optional::elem_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.Optional.elem_type) + return _internal_elem_type(); +} +inline void TypeProto_Optional::unsafe_arena_set_allocated_elem_type( + ::onnx::TypeProto *elem_type) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(elem_type_); + } + elem_type_ = elem_type; + if (elem_type) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.Optional.elem_type) +} +inline ::onnx::TypeProto *TypeProto_Optional::release_elem_type() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = elem_type_; + elem_type_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TypeProto *TypeProto_Optional::unsafe_arena_release_elem_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.Optional.elem_type) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TypeProto *temp = elem_type_; + elem_type_ = nullptr; + return temp; +} +inline ::onnx::TypeProto *TypeProto_Optional::_internal_mutable_elem_type() { + _has_bits_[0] |= 0x00000001u; + if (elem_type_ == nullptr) { + auto *p = CreateMaybeMessage<::onnx::TypeProto>(GetArenaForAllocation()); + elem_type_ = p; + } + return elem_type_; +} +inline ::onnx::TypeProto *TypeProto_Optional::mutable_elem_type() { + ::onnx::TypeProto *_msg = _internal_mutable_elem_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.Optional.elem_type) + return _msg; +} +inline void +TypeProto_Optional::set_allocated_elem_type(::onnx::TypeProto *elem_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete elem_type_; + } + if (elem_type) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(elem_type); + if (message_arena != submessage_arena) { + elem_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, elem_type, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + elem_type_ = elem_type; + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.Optional.elem_type) +} + +// ------------------------------------------------------------------- + +// TypeProto_SparseTensor + +// optional int32 elem_type = 1; +inline bool TypeProto_SparseTensor::_internal_has_elem_type() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool TypeProto_SparseTensor::has_elem_type() const { + return _internal_has_elem_type(); +} +inline void TypeProto_SparseTensor::clear_elem_type() { + elem_type_ = 0; + _has_bits_[0] &= ~0x00000002u; +} +inline int32_t TypeProto_SparseTensor::_internal_elem_type() const { + return elem_type_; +} +inline int32_t TypeProto_SparseTensor::elem_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.elem_type) + return _internal_elem_type(); +} +inline void TypeProto_SparseTensor::_internal_set_elem_type(int32_t value) { + _has_bits_[0] |= 0x00000002u; + elem_type_ = value; +} +inline void TypeProto_SparseTensor::set_elem_type(int32_t value) { + _internal_set_elem_type(value); + // @@protoc_insertion_point(field_set:onnx.TypeProto.SparseTensor.elem_type) +} + +// optional .onnx.TensorShapeProto shape = 2; +inline bool TypeProto_SparseTensor::_internal_has_shape() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + PROTOBUF_ASSUME(!value || shape_ != nullptr); + return value; +} +inline bool TypeProto_SparseTensor::has_shape() const { + return _internal_has_shape(); +} +inline void TypeProto_SparseTensor::clear_shape() { + if (shape_ != nullptr) + shape_->Clear(); + _has_bits_[0] &= ~0x00000001u; +} +inline const ::onnx::TensorShapeProto & +TypeProto_SparseTensor::_internal_shape() const { + const ::onnx::TensorShapeProto *p = shape_; + return p != nullptr ? *p + : reinterpret_cast( + ::onnx::_TensorShapeProto_default_instance_); +} +inline const ::onnx::TensorShapeProto &TypeProto_SparseTensor::shape() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.SparseTensor.shape) + return _internal_shape(); +} +inline void TypeProto_SparseTensor::unsafe_arena_set_allocated_shape( + ::onnx::TensorShapeProto *shape) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(shape_); + } + shape_ = shape; + if (shape) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.SparseTensor.shape) +} +inline ::onnx::TensorShapeProto *TypeProto_SparseTensor::release_shape() { + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorShapeProto *temp = shape_; + shape_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto *old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite *>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { + delete old; + } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::onnx::TensorShapeProto * +TypeProto_SparseTensor::unsafe_arena_release_shape() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.SparseTensor.shape) + _has_bits_[0] &= ~0x00000001u; + ::onnx::TensorShapeProto *temp = shape_; + shape_ = nullptr; + return temp; +} +inline ::onnx::TensorShapeProto * +TypeProto_SparseTensor::_internal_mutable_shape() { + _has_bits_[0] |= 0x00000001u; + if (shape_ == nullptr) { + auto *p = + CreateMaybeMessage<::onnx::TensorShapeProto>(GetArenaForAllocation()); + shape_ = p; + } + return shape_; +} +inline ::onnx::TensorShapeProto *TypeProto_SparseTensor::mutable_shape() { + ::onnx::TensorShapeProto *_msg = _internal_mutable_shape(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.SparseTensor.shape) + return _msg; +} +inline void +TypeProto_SparseTensor::set_allocated_shape(::onnx::TensorShapeProto *shape) { + ::PROTOBUF_NAMESPACE_ID::Arena *message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete shape_; + } + if (shape) { + ::PROTOBUF_NAMESPACE_ID::Arena *submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(shape); + if (message_arena != submessage_arena) { + shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, shape, submessage_arena); + } + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + shape_ = shape; + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.SparseTensor.shape) +} + +// ------------------------------------------------------------------- + +// TypeProto + +// .onnx.TypeProto.Tensor tensor_type = 1; +inline bool TypeProto::_internal_has_tensor_type() const { + return value_case() == kTensorType; +} +inline bool TypeProto::has_tensor_type() const { + return _internal_has_tensor_type(); +} +inline void TypeProto::set_has_tensor_type() { _oneof_case_[0] = kTensorType; } +inline void TypeProto::clear_tensor_type() { + if (_internal_has_tensor_type()) { + if (GetArenaForAllocation() == nullptr) { + delete value_.tensor_type_; + } + clear_has_value(); + } +} +inline ::onnx::TypeProto_Tensor *TypeProto::release_tensor_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.tensor_type) + if (_internal_has_tensor_type()) { + clear_has_value(); + ::onnx::TypeProto_Tensor *temp = value_.tensor_type_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + value_.tensor_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::onnx::TypeProto_Tensor & +TypeProto::_internal_tensor_type() const { + return _internal_has_tensor_type() + ? *value_.tensor_type_ + : reinterpret_cast<::onnx::TypeProto_Tensor &>( + ::onnx::_TypeProto_Tensor_default_instance_); +} +inline const ::onnx::TypeProto_Tensor &TypeProto::tensor_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.tensor_type) + return _internal_tensor_type(); +} +inline ::onnx::TypeProto_Tensor *TypeProto::unsafe_arena_release_tensor_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.tensor_type) + if (_internal_has_tensor_type()) { + clear_has_value(); + ::onnx::TypeProto_Tensor *temp = value_.tensor_type_; + value_.tensor_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TypeProto::unsafe_arena_set_allocated_tensor_type( + ::onnx::TypeProto_Tensor *tensor_type) { + clear_value(); + if (tensor_type) { + set_has_tensor_type(); + value_.tensor_type_ = tensor_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.tensor_type) +} +inline ::onnx::TypeProto_Tensor *TypeProto::_internal_mutable_tensor_type() { + if (!_internal_has_tensor_type()) { + clear_value(); + set_has_tensor_type(); + value_.tensor_type_ = + CreateMaybeMessage<::onnx::TypeProto_Tensor>(GetArenaForAllocation()); + } + return value_.tensor_type_; +} +inline ::onnx::TypeProto_Tensor *TypeProto::mutable_tensor_type() { + ::onnx::TypeProto_Tensor *_msg = _internal_mutable_tensor_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.tensor_type) + return _msg; +} + +// .onnx.TypeProto.Sequence sequence_type = 4; +inline bool TypeProto::_internal_has_sequence_type() const { + return value_case() == kSequenceType; +} +inline bool TypeProto::has_sequence_type() const { + return _internal_has_sequence_type(); +} +inline void TypeProto::set_has_sequence_type() { + _oneof_case_[0] = kSequenceType; +} +inline void TypeProto::clear_sequence_type() { + if (_internal_has_sequence_type()) { + if (GetArenaForAllocation() == nullptr) { + delete value_.sequence_type_; + } + clear_has_value(); + } +} +inline ::onnx::TypeProto_Sequence *TypeProto::release_sequence_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.sequence_type) + if (_internal_has_sequence_type()) { + clear_has_value(); + ::onnx::TypeProto_Sequence *temp = value_.sequence_type_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + value_.sequence_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::onnx::TypeProto_Sequence & +TypeProto::_internal_sequence_type() const { + return _internal_has_sequence_type() + ? *value_.sequence_type_ + : reinterpret_cast<::onnx::TypeProto_Sequence &>( + ::onnx::_TypeProto_Sequence_default_instance_); +} +inline const ::onnx::TypeProto_Sequence &TypeProto::sequence_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.sequence_type) + return _internal_sequence_type(); +} +inline ::onnx::TypeProto_Sequence * +TypeProto::unsafe_arena_release_sequence_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sequence_type) + if (_internal_has_sequence_type()) { + clear_has_value(); + ::onnx::TypeProto_Sequence *temp = value_.sequence_type_; + value_.sequence_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TypeProto::unsafe_arena_set_allocated_sequence_type( + ::onnx::TypeProto_Sequence *sequence_type) { + clear_value(); + if (sequence_type) { + set_has_sequence_type(); + value_.sequence_type_ = sequence_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sequence_type) +} +inline ::onnx::TypeProto_Sequence * +TypeProto::_internal_mutable_sequence_type() { + if (!_internal_has_sequence_type()) { + clear_value(); + set_has_sequence_type(); + value_.sequence_type_ = + CreateMaybeMessage<::onnx::TypeProto_Sequence>(GetArenaForAllocation()); + } + return value_.sequence_type_; +} +inline ::onnx::TypeProto_Sequence *TypeProto::mutable_sequence_type() { + ::onnx::TypeProto_Sequence *_msg = _internal_mutable_sequence_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sequence_type) + return _msg; +} + +// .onnx.TypeProto.Map map_type = 5; +inline bool TypeProto::_internal_has_map_type() const { + return value_case() == kMapType; +} +inline bool TypeProto::has_map_type() const { return _internal_has_map_type(); } +inline void TypeProto::set_has_map_type() { _oneof_case_[0] = kMapType; } +inline void TypeProto::clear_map_type() { + if (_internal_has_map_type()) { + if (GetArenaForAllocation() == nullptr) { + delete value_.map_type_; + } + clear_has_value(); + } +} +inline ::onnx::TypeProto_Map *TypeProto::release_map_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.map_type) + if (_internal_has_map_type()) { + clear_has_value(); + ::onnx::TypeProto_Map *temp = value_.map_type_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + value_.map_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::onnx::TypeProto_Map &TypeProto::_internal_map_type() const { + return _internal_has_map_type() ? *value_.map_type_ + : reinterpret_cast<::onnx::TypeProto_Map &>( + ::onnx::_TypeProto_Map_default_instance_); +} +inline const ::onnx::TypeProto_Map &TypeProto::map_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.map_type) + return _internal_map_type(); +} +inline ::onnx::TypeProto_Map *TypeProto::unsafe_arena_release_map_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.map_type) + if (_internal_has_map_type()) { + clear_has_value(); + ::onnx::TypeProto_Map *temp = value_.map_type_; + value_.map_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TypeProto::unsafe_arena_set_allocated_map_type( + ::onnx::TypeProto_Map *map_type) { + clear_value(); + if (map_type) { + set_has_map_type(); + value_.map_type_ = map_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.map_type) +} +inline ::onnx::TypeProto_Map *TypeProto::_internal_mutable_map_type() { + if (!_internal_has_map_type()) { + clear_value(); + set_has_map_type(); + value_.map_type_ = + CreateMaybeMessage<::onnx::TypeProto_Map>(GetArenaForAllocation()); + } + return value_.map_type_; +} +inline ::onnx::TypeProto_Map *TypeProto::mutable_map_type() { + ::onnx::TypeProto_Map *_msg = _internal_mutable_map_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.map_type) + return _msg; +} + +// .onnx.TypeProto.Optional optional_type = 9; +inline bool TypeProto::_internal_has_optional_type() const { + return value_case() == kOptionalType; +} +inline bool TypeProto::has_optional_type() const { + return _internal_has_optional_type(); +} +inline void TypeProto::set_has_optional_type() { + _oneof_case_[0] = kOptionalType; +} +inline void TypeProto::clear_optional_type() { + if (_internal_has_optional_type()) { + if (GetArenaForAllocation() == nullptr) { + delete value_.optional_type_; + } + clear_has_value(); + } +} +inline ::onnx::TypeProto_Optional *TypeProto::release_optional_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.optional_type) + if (_internal_has_optional_type()) { + clear_has_value(); + ::onnx::TypeProto_Optional *temp = value_.optional_type_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + value_.optional_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::onnx::TypeProto_Optional & +TypeProto::_internal_optional_type() const { + return _internal_has_optional_type() + ? *value_.optional_type_ + : reinterpret_cast<::onnx::TypeProto_Optional &>( + ::onnx::_TypeProto_Optional_default_instance_); +} +inline const ::onnx::TypeProto_Optional &TypeProto::optional_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.optional_type) + return _internal_optional_type(); +} +inline ::onnx::TypeProto_Optional * +TypeProto::unsafe_arena_release_optional_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.optional_type) + if (_internal_has_optional_type()) { + clear_has_value(); + ::onnx::TypeProto_Optional *temp = value_.optional_type_; + value_.optional_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TypeProto::unsafe_arena_set_allocated_optional_type( + ::onnx::TypeProto_Optional *optional_type) { + clear_value(); + if (optional_type) { + set_has_optional_type(); + value_.optional_type_ = optional_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.optional_type) +} +inline ::onnx::TypeProto_Optional * +TypeProto::_internal_mutable_optional_type() { + if (!_internal_has_optional_type()) { + clear_value(); + set_has_optional_type(); + value_.optional_type_ = + CreateMaybeMessage<::onnx::TypeProto_Optional>(GetArenaForAllocation()); + } + return value_.optional_type_; +} +inline ::onnx::TypeProto_Optional *TypeProto::mutable_optional_type() { + ::onnx::TypeProto_Optional *_msg = _internal_mutable_optional_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.optional_type) + return _msg; +} + +// .onnx.TypeProto.SparseTensor sparse_tensor_type = 8; +inline bool TypeProto::_internal_has_sparse_tensor_type() const { + return value_case() == kSparseTensorType; +} +inline bool TypeProto::has_sparse_tensor_type() const { + return _internal_has_sparse_tensor_type(); +} +inline void TypeProto::set_has_sparse_tensor_type() { + _oneof_case_[0] = kSparseTensorType; +} +inline void TypeProto::clear_sparse_tensor_type() { + if (_internal_has_sparse_tensor_type()) { + if (GetArenaForAllocation() == nullptr) { + delete value_.sparse_tensor_type_; + } + clear_has_value(); + } +} +inline ::onnx::TypeProto_SparseTensor *TypeProto::release_sparse_tensor_type() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.sparse_tensor_type) + if (_internal_has_sparse_tensor_type()) { + clear_has_value(); + ::onnx::TypeProto_SparseTensor *temp = value_.sparse_tensor_type_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + value_.sparse_tensor_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::onnx::TypeProto_SparseTensor & +TypeProto::_internal_sparse_tensor_type() const { + return _internal_has_sparse_tensor_type() + ? *value_.sparse_tensor_type_ + : reinterpret_cast<::onnx::TypeProto_SparseTensor &>( + ::onnx::_TypeProto_SparseTensor_default_instance_); +} +inline const ::onnx::TypeProto_SparseTensor & +TypeProto::sparse_tensor_type() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.sparse_tensor_type) + return _internal_sparse_tensor_type(); +} +inline ::onnx::TypeProto_SparseTensor * +TypeProto::unsafe_arena_release_sparse_tensor_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:onnx.TypeProto.sparse_tensor_type) + if (_internal_has_sparse_tensor_type()) { + clear_has_value(); + ::onnx::TypeProto_SparseTensor *temp = value_.sparse_tensor_type_; + value_.sparse_tensor_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void TypeProto::unsafe_arena_set_allocated_sparse_tensor_type( + ::onnx::TypeProto_SparseTensor *sparse_tensor_type) { + clear_value(); + if (sparse_tensor_type) { + set_has_sparse_tensor_type(); + value_.sparse_tensor_type_ = sparse_tensor_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:onnx.TypeProto.sparse_tensor_type) +} +inline ::onnx::TypeProto_SparseTensor * +TypeProto::_internal_mutable_sparse_tensor_type() { + if (!_internal_has_sparse_tensor_type()) { + clear_value(); + set_has_sparse_tensor_type(); + value_.sparse_tensor_type_ = + CreateMaybeMessage<::onnx::TypeProto_SparseTensor>( + GetArenaForAllocation()); + } + return value_.sparse_tensor_type_; +} +inline ::onnx::TypeProto_SparseTensor *TypeProto::mutable_sparse_tensor_type() { + ::onnx::TypeProto_SparseTensor *_msg = _internal_mutable_sparse_tensor_type(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.sparse_tensor_type) + return _msg; +} + +// optional string denotation = 6; +inline bool TypeProto::_internal_has_denotation() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool TypeProto::has_denotation() const { + return _internal_has_denotation(); +} +inline void TypeProto::clear_denotation() { + denotation_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &TypeProto::denotation() const { + // @@protoc_insertion_point(field_get:onnx.TypeProto.denotation) + return _internal_denotation(); +} +template +inline PROTOBUF_ALWAYS_INLINE void TypeProto::set_denotation(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + denotation_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.TypeProto.denotation) +} +inline std::string *TypeProto::mutable_denotation() { + std::string *_s = _internal_mutable_denotation(); + // @@protoc_insertion_point(field_mutable:onnx.TypeProto.denotation) + return _s; +} +inline const std::string &TypeProto::_internal_denotation() const { + return denotation_.Get(); +} +inline void TypeProto::_internal_set_denotation(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + denotation_.Set(value, GetArenaForAllocation()); +} +inline std::string *TypeProto::_internal_mutable_denotation() { + _has_bits_[0] |= 0x00000001u; + return denotation_.Mutable(GetArenaForAllocation()); +} +inline std::string *TypeProto::release_denotation() { + // @@protoc_insertion_point(field_release:onnx.TypeProto.denotation) + if (!_internal_has_denotation()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = denotation_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (denotation_.IsDefault()) { + denotation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void TypeProto::set_allocated_denotation(std::string *denotation) { + if (denotation != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + denotation_.SetAllocated(denotation, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (denotation_.IsDefault()) { + denotation_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.TypeProto.denotation) +} + +inline bool TypeProto::has_value() const { + return value_case() != VALUE_NOT_SET; +} +inline void TypeProto::clear_has_value() { _oneof_case_[0] = VALUE_NOT_SET; } +inline TypeProto::ValueCase TypeProto::value_case() const { + return TypeProto::ValueCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// OperatorSetIdProto + +// optional string domain = 1; +inline bool OperatorSetIdProto::_internal_has_domain() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool OperatorSetIdProto::has_domain() const { + return _internal_has_domain(); +} +inline void OperatorSetIdProto::clear_domain() { + domain_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &OperatorSetIdProto::domain() const { + // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.domain) + return _internal_domain(); +} +template +inline PROTOBUF_ALWAYS_INLINE void +OperatorSetIdProto::set_domain(ArgT0 &&arg0, ArgT... args) { + _has_bits_[0] |= 0x00000001u; + domain_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.domain) +} +inline std::string *OperatorSetIdProto::mutable_domain() { + std::string *_s = _internal_mutable_domain(); + // @@protoc_insertion_point(field_mutable:onnx.OperatorSetIdProto.domain) + return _s; +} +inline const std::string &OperatorSetIdProto::_internal_domain() const { + return domain_.Get(); +} +inline void OperatorSetIdProto::_internal_set_domain(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + domain_.Set(value, GetArenaForAllocation()); +} +inline std::string *OperatorSetIdProto::_internal_mutable_domain() { + _has_bits_[0] |= 0x00000001u; + return domain_.Mutable(GetArenaForAllocation()); +} +inline std::string *OperatorSetIdProto::release_domain() { + // @@protoc_insertion_point(field_release:onnx.OperatorSetIdProto.domain) + if (!_internal_has_domain()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = domain_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void OperatorSetIdProto::set_allocated_domain(std::string *domain) { + if (domain != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + domain_.SetAllocated(domain, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.OperatorSetIdProto.domain) +} + +// optional int64 version = 2; +inline bool OperatorSetIdProto::_internal_has_version() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool OperatorSetIdProto::has_version() const { + return _internal_has_version(); +} +inline void OperatorSetIdProto::clear_version() { + version_ = int64_t{0}; + _has_bits_[0] &= ~0x00000002u; +} +inline int64_t OperatorSetIdProto::_internal_version() const { + return version_; +} +inline int64_t OperatorSetIdProto::version() const { + // @@protoc_insertion_point(field_get:onnx.OperatorSetIdProto.version) + return _internal_version(); +} +inline void OperatorSetIdProto::_internal_set_version(int64_t value) { + _has_bits_[0] |= 0x00000002u; + version_ = value; +} +inline void OperatorSetIdProto::set_version(int64_t value) { + _internal_set_version(value); + // @@protoc_insertion_point(field_set:onnx.OperatorSetIdProto.version) +} + +// ------------------------------------------------------------------- + +// FunctionProto + +// optional string name = 1; +inline bool FunctionProto::_internal_has_name() const { + bool value = (_has_bits_[0] & 0x00000001u) != 0; + return value; +} +inline bool FunctionProto::has_name() const { return _internal_has_name(); } +inline void FunctionProto::clear_name() { + name_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000001u; +} +inline const std::string &FunctionProto::name() const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_name(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000001u; + name_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.name) +} +inline std::string *FunctionProto::mutable_name() { + std::string *_s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.name) + return _s; +} +inline const std::string &FunctionProto::_internal_name() const { + return name_.Get(); +} +inline void FunctionProto::_internal_set_name(const std::string &value) { + _has_bits_[0] |= 0x00000001u; + name_.Set(value, GetArenaForAllocation()); +} +inline std::string *FunctionProto::_internal_mutable_name() { + _has_bits_[0] |= 0x00000001u; + return name_.Mutable(GetArenaForAllocation()); +} +inline std::string *FunctionProto::release_name() { + // @@protoc_insertion_point(field_release:onnx.FunctionProto.name) + if (!_internal_has_name()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000001u; + auto *p = name_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FunctionProto::set_allocated_name(std::string *name) { + if (name != nullptr) { + _has_bits_[0] |= 0x00000001u; + } else { + _has_bits_[0] &= ~0x00000001u; + } + name_.SetAllocated(name, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault()) { + name_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.name) +} + +// repeated string input = 4; +inline int FunctionProto::_internal_input_size() const { return input_.size(); } +inline int FunctionProto::input_size() const { return _internal_input_size(); } +inline void FunctionProto::clear_input() { input_.Clear(); } +inline std::string *FunctionProto::add_input() { + std::string *_s = _internal_add_input(); + // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.input) + return _s; +} +inline const std::string &FunctionProto::_internal_input(int index) const { + return input_.Get(index); +} +inline const std::string &FunctionProto::input(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.input) + return _internal_input(index); +} +inline std::string *FunctionProto::mutable_input(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.input) + return input_.Mutable(index); +} +inline void FunctionProto::set_input(int index, const std::string &value) { + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.input) +} +inline void FunctionProto::set_input(int index, std::string &&value) { + input_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.input) +} +inline void FunctionProto::set_input(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + input_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.input) +} +inline void FunctionProto::set_input(int index, const char *value, + size_t size) { + input_.Mutable(index)->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.input) +} +inline std::string *FunctionProto::_internal_add_input() { + return input_.Add(); +} +inline void FunctionProto::add_input(const std::string &value) { + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.input) +} +inline void FunctionProto::add_input(std::string &&value) { + input_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.input) +} +inline void FunctionProto::add_input(const char *value) { + GOOGLE_DCHECK(value != nullptr); + input_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.input) +} +inline void FunctionProto::add_input(const char *value, size_t size) { + input_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.input) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +FunctionProto::input() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.input) + return input_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +FunctionProto::mutable_input() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.input) + return &input_; +} + +// repeated string output = 5; +inline int FunctionProto::_internal_output_size() const { + return output_.size(); +} +inline int FunctionProto::output_size() const { + return _internal_output_size(); +} +inline void FunctionProto::clear_output() { output_.Clear(); } +inline std::string *FunctionProto::add_output() { + std::string *_s = _internal_add_output(); + // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.output) + return _s; +} +inline const std::string &FunctionProto::_internal_output(int index) const { + return output_.Get(index); +} +inline const std::string &FunctionProto::output(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.output) + return _internal_output(index); +} +inline std::string *FunctionProto::mutable_output(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.output) + return output_.Mutable(index); +} +inline void FunctionProto::set_output(int index, const std::string &value) { + output_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.output) +} +inline void FunctionProto::set_output(int index, std::string &&value) { + output_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.output) +} +inline void FunctionProto::set_output(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + output_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.output) +} +inline void FunctionProto::set_output(int index, const char *value, + size_t size) { + output_.Mutable(index)->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.output) +} +inline std::string *FunctionProto::_internal_add_output() { + return output_.Add(); +} +inline void FunctionProto::add_output(const std::string &value) { + output_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.output) +} +inline void FunctionProto::add_output(std::string &&value) { + output_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.output) +} +inline void FunctionProto::add_output(const char *value) { + GOOGLE_DCHECK(value != nullptr); + output_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.output) +} +inline void FunctionProto::add_output(const char *value, size_t size) { + output_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.output) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +FunctionProto::output() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.output) + return output_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +FunctionProto::mutable_output() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.output) + return &output_; +} + +// repeated string attribute = 6; +inline int FunctionProto::_internal_attribute_size() const { + return attribute_.size(); +} +inline int FunctionProto::attribute_size() const { + return _internal_attribute_size(); +} +inline void FunctionProto::clear_attribute() { attribute_.Clear(); } +inline std::string *FunctionProto::add_attribute() { + std::string *_s = _internal_add_attribute(); + // @@protoc_insertion_point(field_add_mutable:onnx.FunctionProto.attribute) + return _s; +} +inline const std::string &FunctionProto::_internal_attribute(int index) const { + return attribute_.Get(index); +} +inline const std::string &FunctionProto::attribute(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute) + return _internal_attribute(index); +} +inline std::string *FunctionProto::mutable_attribute(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute) + return attribute_.Mutable(index); +} +inline void FunctionProto::set_attribute(int index, const std::string &value) { + attribute_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute) +} +inline void FunctionProto::set_attribute(int index, std::string &&value) { + attribute_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.attribute) +} +inline void FunctionProto::set_attribute(int index, const char *value) { + GOOGLE_DCHECK(value != nullptr); + attribute_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:onnx.FunctionProto.attribute) +} +inline void FunctionProto::set_attribute(int index, const char *value, + size_t size) { + attribute_.Mutable(index)->assign(reinterpret_cast(value), + size); + // @@protoc_insertion_point(field_set_pointer:onnx.FunctionProto.attribute) +} +inline std::string *FunctionProto::_internal_add_attribute() { + return attribute_.Add(); +} +inline void FunctionProto::add_attribute(const std::string &value) { + attribute_.Add()->assign(value); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute) +} +inline void FunctionProto::add_attribute(std::string &&value) { + attribute_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute) +} +inline void FunctionProto::add_attribute(const char *value) { + GOOGLE_DCHECK(value != nullptr); + attribute_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:onnx.FunctionProto.attribute) +} +inline void FunctionProto::add_attribute(const char *value, size_t size) { + attribute_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:onnx.FunctionProto.attribute) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField & +FunctionProto::attribute() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute) + return attribute_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField * +FunctionProto::mutable_attribute() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute) + return &attribute_; +} + +// repeated .onnx.AttributeProto attribute_proto = 11; +inline int FunctionProto::_internal_attribute_proto_size() const { + return attribute_proto_.size(); +} +inline int FunctionProto::attribute_proto_size() const { + return _internal_attribute_proto_size(); +} +inline void FunctionProto::clear_attribute_proto() { attribute_proto_.Clear(); } +inline ::onnx::AttributeProto * +FunctionProto::mutable_attribute_proto(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.attribute_proto) + return attribute_proto_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> * +FunctionProto::mutable_attribute_proto() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.attribute_proto) + return &attribute_proto_; +} +inline const ::onnx::AttributeProto & +FunctionProto::_internal_attribute_proto(int index) const { + return attribute_proto_.Get(index); +} +inline const ::onnx::AttributeProto & +FunctionProto::attribute_proto(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.attribute_proto) + return _internal_attribute_proto(index); +} +inline ::onnx::AttributeProto *FunctionProto::_internal_add_attribute_proto() { + return attribute_proto_.Add(); +} +inline ::onnx::AttributeProto *FunctionProto::add_attribute_proto() { + ::onnx::AttributeProto *_add = _internal_add_attribute_proto(); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.attribute_proto) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::AttributeProto> & +FunctionProto::attribute_proto() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.attribute_proto) + return attribute_proto_; +} + +// repeated .onnx.NodeProto node = 7; +inline int FunctionProto::_internal_node_size() const { return node_.size(); } +inline int FunctionProto::node_size() const { return _internal_node_size(); } +inline void FunctionProto::clear_node() { node_.Clear(); } +inline ::onnx::NodeProto *FunctionProto::mutable_node(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.node) + return node_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> * +FunctionProto::mutable_node() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.node) + return &node_; +} +inline const ::onnx::NodeProto &FunctionProto::_internal_node(int index) const { + return node_.Get(index); +} +inline const ::onnx::NodeProto &FunctionProto::node(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.node) + return _internal_node(index); +} +inline ::onnx::NodeProto *FunctionProto::_internal_add_node() { + return node_.Add(); +} +inline ::onnx::NodeProto *FunctionProto::add_node() { + ::onnx::NodeProto *_add = _internal_add_node(); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.node) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::NodeProto> & +FunctionProto::node() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.node) + return node_; +} + +// optional string doc_string = 8; +inline bool FunctionProto::_internal_has_doc_string() const { + bool value = (_has_bits_[0] & 0x00000002u) != 0; + return value; +} +inline bool FunctionProto::has_doc_string() const { + return _internal_has_doc_string(); +} +inline void FunctionProto::clear_doc_string() { + doc_string_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000002u; +} +inline const std::string &FunctionProto::doc_string() const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.doc_string) + return _internal_doc_string(); +} +template +inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_doc_string(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(static_cast(arg0), args..., + GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.doc_string) +} +inline std::string *FunctionProto::mutable_doc_string() { + std::string *_s = _internal_mutable_doc_string(); + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.doc_string) + return _s; +} +inline const std::string &FunctionProto::_internal_doc_string() const { + return doc_string_.Get(); +} +inline void FunctionProto::_internal_set_doc_string(const std::string &value) { + _has_bits_[0] |= 0x00000002u; + doc_string_.Set(value, GetArenaForAllocation()); +} +inline std::string *FunctionProto::_internal_mutable_doc_string() { + _has_bits_[0] |= 0x00000002u; + return doc_string_.Mutable(GetArenaForAllocation()); +} +inline std::string *FunctionProto::release_doc_string() { + // @@protoc_insertion_point(field_release:onnx.FunctionProto.doc_string) + if (!_internal_has_doc_string()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000002u; + auto *p = doc_string_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FunctionProto::set_allocated_doc_string(std::string *doc_string) { + if (doc_string != nullptr) { + _has_bits_[0] |= 0x00000002u; + } else { + _has_bits_[0] &= ~0x00000002u; + } + doc_string_.SetAllocated(doc_string, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (doc_string_.IsDefault()) { + doc_string_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.doc_string) +} + +// repeated .onnx.OperatorSetIdProto opset_import = 9; +inline int FunctionProto::_internal_opset_import_size() const { + return opset_import_.size(); +} +inline int FunctionProto::opset_import_size() const { + return _internal_opset_import_size(); +} +inline void FunctionProto::clear_opset_import() { opset_import_.Clear(); } +inline ::onnx::OperatorSetIdProto * +FunctionProto::mutable_opset_import(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.opset_import) + return opset_import_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::OperatorSetIdProto> * +FunctionProto::mutable_opset_import() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.opset_import) + return &opset_import_; +} +inline const ::onnx::OperatorSetIdProto & +FunctionProto::_internal_opset_import(int index) const { + return opset_import_.Get(index); +} +inline const ::onnx::OperatorSetIdProto & +FunctionProto::opset_import(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.opset_import) + return _internal_opset_import(index); +} +inline ::onnx::OperatorSetIdProto *FunctionProto::_internal_add_opset_import() { + return opset_import_.Add(); +} +inline ::onnx::OperatorSetIdProto *FunctionProto::add_opset_import() { + ::onnx::OperatorSetIdProto *_add = _internal_add_opset_import(); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.opset_import) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::OperatorSetIdProto> & +FunctionProto::opset_import() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.opset_import) + return opset_import_; +} + +// optional string domain = 10; +inline bool FunctionProto::_internal_has_domain() const { + bool value = (_has_bits_[0] & 0x00000004u) != 0; + return value; +} +inline bool FunctionProto::has_domain() const { return _internal_has_domain(); } +inline void FunctionProto::clear_domain() { + domain_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000004u; +} +inline const std::string &FunctionProto::domain() const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.domain) + return _internal_domain(); +} +template +inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_domain(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000004u; + domain_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.domain) +} +inline std::string *FunctionProto::mutable_domain() { + std::string *_s = _internal_mutable_domain(); + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.domain) + return _s; +} +inline const std::string &FunctionProto::_internal_domain() const { + return domain_.Get(); +} +inline void FunctionProto::_internal_set_domain(const std::string &value) { + _has_bits_[0] |= 0x00000004u; + domain_.Set(value, GetArenaForAllocation()); +} +inline std::string *FunctionProto::_internal_mutable_domain() { + _has_bits_[0] |= 0x00000004u; + return domain_.Mutable(GetArenaForAllocation()); +} +inline std::string *FunctionProto::release_domain() { + // @@protoc_insertion_point(field_release:onnx.FunctionProto.domain) + if (!_internal_has_domain()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000004u; + auto *p = domain_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FunctionProto::set_allocated_domain(std::string *domain) { + if (domain != nullptr) { + _has_bits_[0] |= 0x00000004u; + } else { + _has_bits_[0] &= ~0x00000004u; + } + domain_.SetAllocated(domain, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (domain_.IsDefault()) { + domain_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.domain) +} + +// optional string overload = 13; +inline bool FunctionProto::_internal_has_overload() const { + bool value = (_has_bits_[0] & 0x00000008u) != 0; + return value; +} +inline bool FunctionProto::has_overload() const { + return _internal_has_overload(); +} +inline void FunctionProto::clear_overload() { + overload_.ClearToEmpty(); + _has_bits_[0] &= ~0x00000008u; +} +inline const std::string &FunctionProto::overload() const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.overload) + return _internal_overload(); +} +template +inline PROTOBUF_ALWAYS_INLINE void FunctionProto::set_overload(ArgT0 &&arg0, + ArgT... args) { + _has_bits_[0] |= 0x00000008u; + overload_.Set(static_cast(arg0), args..., GetArenaForAllocation()); + // @@protoc_insertion_point(field_set:onnx.FunctionProto.overload) +} +inline std::string *FunctionProto::mutable_overload() { + std::string *_s = _internal_mutable_overload(); + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.overload) + return _s; +} +inline const std::string &FunctionProto::_internal_overload() const { + return overload_.Get(); +} +inline void FunctionProto::_internal_set_overload(const std::string &value) { + _has_bits_[0] |= 0x00000008u; + overload_.Set(value, GetArenaForAllocation()); +} +inline std::string *FunctionProto::_internal_mutable_overload() { + _has_bits_[0] |= 0x00000008u; + return overload_.Mutable(GetArenaForAllocation()); +} +inline std::string *FunctionProto::release_overload() { + // @@protoc_insertion_point(field_release:onnx.FunctionProto.overload) + if (!_internal_has_overload()) { + return nullptr; + } + _has_bits_[0] &= ~0x00000008u; + auto *p = overload_.Release(); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (overload_.IsDefault()) { + overload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + return p; +} +inline void FunctionProto::set_allocated_overload(std::string *overload) { + if (overload != nullptr) { + _has_bits_[0] |= 0x00000008u; + } else { + _has_bits_[0] &= ~0x00000008u; + } + overload_.SetAllocated(overload, GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (overload_.IsDefault()) { + overload_.Set("", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING + // @@protoc_insertion_point(field_set_allocated:onnx.FunctionProto.overload) +} + +// repeated .onnx.ValueInfoProto value_info = 12; +inline int FunctionProto::_internal_value_info_size() const { + return value_info_.size(); +} +inline int FunctionProto::value_info_size() const { + return _internal_value_info_size(); +} +inline void FunctionProto::clear_value_info() { value_info_.Clear(); } +inline ::onnx::ValueInfoProto *FunctionProto::mutable_value_info(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.value_info) + return value_info_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> * +FunctionProto::mutable_value_info() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.value_info) + return &value_info_; +} +inline const ::onnx::ValueInfoProto & +FunctionProto::_internal_value_info(int index) const { + return value_info_.Get(index); +} +inline const ::onnx::ValueInfoProto & +FunctionProto::value_info(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.value_info) + return _internal_value_info(index); +} +inline ::onnx::ValueInfoProto *FunctionProto::_internal_add_value_info() { + return value_info_.Add(); +} +inline ::onnx::ValueInfoProto *FunctionProto::add_value_info() { + ::onnx::ValueInfoProto *_add = _internal_add_value_info(); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.value_info) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::ValueInfoProto> & +FunctionProto::value_info() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.value_info) + return value_info_; +} + +// repeated .onnx.StringStringEntryProto metadata_props = 14; +inline int FunctionProto::_internal_metadata_props_size() const { + return metadata_props_.size(); +} +inline int FunctionProto::metadata_props_size() const { + return _internal_metadata_props_size(); +} +inline void FunctionProto::clear_metadata_props() { metadata_props_.Clear(); } +inline ::onnx::StringStringEntryProto * +FunctionProto::mutable_metadata_props(int index) { + // @@protoc_insertion_point(field_mutable:onnx.FunctionProto.metadata_props) + return metadata_props_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<::onnx::StringStringEntryProto> + *FunctionProto::mutable_metadata_props() { + // @@protoc_insertion_point(field_mutable_list:onnx.FunctionProto.metadata_props) + return &metadata_props_; +} +inline const ::onnx::StringStringEntryProto & +FunctionProto::_internal_metadata_props(int index) const { + return metadata_props_.Get(index); +} +inline const ::onnx::StringStringEntryProto & +FunctionProto::metadata_props(int index) const { + // @@protoc_insertion_point(field_get:onnx.FunctionProto.metadata_props) + return _internal_metadata_props(index); +} +inline ::onnx::StringStringEntryProto * +FunctionProto::_internal_add_metadata_props() { + return metadata_props_.Add(); +} +inline ::onnx::StringStringEntryProto *FunctionProto::add_metadata_props() { + ::onnx::StringStringEntryProto *_add = _internal_add_metadata_props(); + // @@protoc_insertion_point(field_add:onnx.FunctionProto.metadata_props) + return _add; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< + ::onnx::StringStringEntryProto> & +FunctionProto::metadata_props() const { + // @@protoc_insertion_point(field_list:onnx.FunctionProto.metadata_props) + return metadata_props_; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// @@protoc_insertion_point(namespace_scope) + +} // namespace onnx + +PROTOBUF_NAMESPACE_OPEN + +template <> +struct is_proto_enum<::onnx::AttributeProto_AttributeType> : ::std::true_type { +}; +template <> +struct is_proto_enum<::onnx::TensorProto_DataType> : ::std::true_type {}; +template <> +struct is_proto_enum<::onnx::TensorProto_DataLocation> : ::std::true_type {}; +template <> struct is_proto_enum<::onnx::Version> : ::std::true_type {}; +template <> struct is_proto_enum<::onnx::OperatorStatus> : ::std::true_type {}; + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_onnx_2eproto