CoCalc -- attr_value.pb.cc

GitHub Repository: Tetragramm/opencv
Path: blob/master/modules/dnn/misc/tensorflow/attr_value.pb.cc
¹⁶³⁵⁸ views
1
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
// source: attr_value.proto
3

4
#include "attr_value.pb.h"
5

6
#include <algorithm>
7

8
#include <google/protobuf/stubs/common.h>
9
#include <google/protobuf/stubs/port.h>
10
#include <google/protobuf/stubs/once.h>
11
#include <google/protobuf/io/coded_stream.h>
12
#include <google/protobuf/wire_format_lite_inl.h>
13
#include <google/protobuf/descriptor.h>
14
#include <google/protobuf/generated_message_reflection.h>
15
#include <google/protobuf/reflection_ops.h>
16
#include <google/protobuf/wire_format.h>
17
// This is a temporary google only hack
18
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
19
#include "third_party/protobuf/version.h"
20
#endif
21
// @@protoc_insertion_point(includes)
22
namespace opencv_tensorflow {
23
class AttrValue_ListValueDefaultTypeInternal {
24
 public:
25
  ::google::protobuf::internal::ExplicitlyConstructed<AttrValue_ListValue>
26
      _instance;
27
} _AttrValue_ListValue_default_instance_;
28
class AttrValueDefaultTypeInternal {
29
 public:
30
  ::google::protobuf::internal::ExplicitlyConstructed<AttrValue>
31
      _instance;
32
  ::google::protobuf::internal::ArenaStringPtr s_;
33
  ::google::protobuf::int64 i_;
34
  float f_;
35
  bool b_;
36
  int type_;
37
  const ::opencv_tensorflow::TensorShapeProto* shape_;
38
  const ::opencv_tensorflow::TensorProto* tensor_;
39
  const ::opencv_tensorflow::AttrValue_ListValue* list_;
40
  const ::opencv_tensorflow::NameAttrList* func_;
41
  ::google::protobuf::internal::ArenaStringPtr placeholder_;
42
} _AttrValue_default_instance_;
43
class NameAttrList_AttrEntry_DoNotUseDefaultTypeInternal {
44
 public:
45
  ::google::protobuf::internal::ExplicitlyConstructed<NameAttrList_AttrEntry_DoNotUse>
46
      _instance;
47
} _NameAttrList_AttrEntry_DoNotUse_default_instance_;
48
class NameAttrListDefaultTypeInternal {
49
 public:
50
  ::google::protobuf::internal::ExplicitlyConstructed<NameAttrList>
51
      _instance;
52
} _NameAttrList_default_instance_;
53
}  // namespace opencv_tensorflow
54
namespace protobuf_attr_5fvalue_2eproto {
55
void InitDefaultsAttrValue_ListValueImpl() {
56
  GOOGLE_PROTOBUF_VERIFY_VERSION;
57

58
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
59
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
60
#else
61
  ::google::protobuf::internal::InitProtobufDefaults();
62
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
63
  protobuf_tensor_5fshape_2eproto::InitDefaultsTensorShapeProto();
64
  protobuf_tensor_2eproto::InitDefaultsTensorProto();
65
  {
66
    void* ptr = &::opencv_tensorflow::_AttrValue_ListValue_default_instance_;
67
    new (ptr) ::opencv_tensorflow::AttrValue_ListValue();
68
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
69
  }
70
  ::opencv_tensorflow::AttrValue_ListValue::InitAsDefaultInstance();
71
}
72

73
void InitDefaultsAttrValue_ListValue() {
74
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
75
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsAttrValue_ListValueImpl);
76
}
77

78
void InitDefaultsAttrValueImpl() {
79
  GOOGLE_PROTOBUF_VERIFY_VERSION;
80

81
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
82
  ::google::protobuf::internal::InitProtobufDefaultsForceUnique();
83
#else
84
  ::google::protobuf::internal::InitProtobufDefaults();
85
#endif  // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
86
  protobuf_tensor_5fshape_2eproto::InitDefaultsTensorShapeProto();
87
  protobuf_tensor_2eproto::InitDefaultsTensorProto();
88
  protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue_ListValue();
89
  {
90
    void* ptr = &::opencv_tensorflow::_AttrValue_default_instance_;
91
    new (ptr) ::opencv_tensorflow::AttrValue();
92
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
93
  }
94
  {
95
    void* ptr = &::opencv_tensorflow::_NameAttrList_AttrEntry_DoNotUse_default_instance_;
96
    new (ptr) ::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse();
97
  }
98
  {
99
    void* ptr = &::opencv_tensorflow::_NameAttrList_default_instance_;
100
    new (ptr) ::opencv_tensorflow::NameAttrList();
101
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
102
  }
103
  ::opencv_tensorflow::AttrValue::InitAsDefaultInstance();
104
  ::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse::InitAsDefaultInstance();
105
  ::opencv_tensorflow::NameAttrList::InitAsDefaultInstance();
106
}
107

108
void InitDefaultsAttrValue() {
109
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
110
  ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsAttrValueImpl);
111
}
112

113
::google::protobuf::Metadata file_level_metadata[4];
114

115
const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
116
  ~0u,  // no _has_bits_
117
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, _internal_metadata_),
118
  ~0u,  // no _extensions_
119
  ~0u,  // no _oneof_case_
120
  ~0u,  // no _weak_field_map_
121
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, s_),
122
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, i_),
123
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, f_),
124
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, b_),
125
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, type_),
126
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, shape_),
127
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue_ListValue, tensor_),
128
  ~0u,  // no _has_bits_
129
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue, _internal_metadata_),
130
  ~0u,  // no _extensions_
131
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue, _oneof_case_[0]),
132
  ~0u,  // no _weak_field_map_
133
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, s_),
134
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, i_),
135
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, f_),
136
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, b_),
137
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, type_),
138
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, shape_),
139
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, tensor_),
140
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, list_),
141
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, func_),
142
  offsetof(::opencv_tensorflow::AttrValueDefaultTypeInternal, placeholder_),
143
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::AttrValue, value_),
144
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse, _has_bits_),
145
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse, _internal_metadata_),
146
  ~0u,  // no _extensions_
147
  ~0u,  // no _oneof_case_
148
  ~0u,  // no _weak_field_map_
149
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse, key_),
150
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse, value_),
151
  0,
152
  1,
153
  ~0u,  // no _has_bits_
154
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList, _internal_metadata_),
155
  ~0u,  // no _extensions_
156
  ~0u,  // no _oneof_case_
157
  ~0u,  // no _weak_field_map_
158
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList, name_),
159
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::opencv_tensorflow::NameAttrList, attr_),
160
};
161
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
162
  { 0, -1, sizeof(::opencv_tensorflow::AttrValue_ListValue)},
163
  { 12, -1, sizeof(::opencv_tensorflow::AttrValue)},
164
  { 28, 35, sizeof(::opencv_tensorflow::NameAttrList_AttrEntry_DoNotUse)},
165
  { 37, -1, sizeof(::opencv_tensorflow::NameAttrList)},
166
};
167

168
static ::google::protobuf::Message const * const file_default_instances[] = {
169
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_tensorflow::_AttrValue_ListValue_default_instance_),
170
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_tensorflow::_AttrValue_default_instance_),
171
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_tensorflow::_NameAttrList_AttrEntry_DoNotUse_default_instance_),
172
  reinterpret_cast<const ::google::protobuf::Message*>(&::opencv_tensorflow::_NameAttrList_default_instance_),
173
};
174

175
void protobuf_AssignDescriptors() {
176
  AddDescriptors();
177
  ::google::protobuf::MessageFactory* factory = NULL;
178
  AssignDescriptors(
179
      "attr_value.proto", schemas, file_default_instances, TableStruct::offsets, factory,
180
      file_level_metadata, NULL, NULL);
181
}
182

183
void protobuf_AssignDescriptorsOnce() {
184
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
185
  ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);
186
}
187

188
void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
189
void protobuf_RegisterTypes(const ::std::string&) {
190
  protobuf_AssignDescriptorsOnce();
191
  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 4);
192
}
193

194
void AddDescriptorsImpl() {
195
  InitDefaults();
196
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
197
      "\n\020attr_value.proto\022\021opencv_tensorflow\032\014t"
198
      "ensor.proto\032\022tensor_shape.proto\032\013types.p"
199
      "roto\"\266\004\n\tAttrValue\022\013\n\001s\030\002 \001(\014H\000\022\013\n\001i\030\003 \001"
200
      "(\003H\000\022\013\n\001f\030\004 \001(\002H\000\022\013\n\001b\030\005 \001(\010H\000\022+\n\004type\030\006"
201
      " \001(\0162\033.opencv_tensorflow.DataTypeH\000\0224\n\005s"
202
      "hape\030\007 \001(\0132#.opencv_tensorflow.TensorSha"
203
      "peProtoH\000\0220\n\006tensor\030\010 \001(\0132\036.opencv_tenso"
204
      "rflow.TensorProtoH\000\0226\n\004list\030\001 \001(\0132&.open"
205
      "cv_tensorflow.AttrValue.ListValueH\000\022/\n\004f"
206
      "unc\030\n \001(\0132\037.opencv_tensorflow.NameAttrLi"
207
      "stH\000\022\025\n\013placeholder\030\t \001(\tH\000\032\326\001\n\tListValu"
208
      "e\022\t\n\001s\030\002 \003(\014\022\r\n\001i\030\003 \003(\003B\002\020\001\022\r\n\001f\030\004 \003(\002B\002"
209
      "\020\001\022\r\n\001b\030\005 \003(\010B\002\020\001\022-\n\004type\030\006 \003(\0162\033.opencv"
210
      "_tensorflow.DataTypeB\002\020\001\0222\n\005shape\030\007 \003(\0132"
211
      "#.opencv_tensorflow.TensorShapeProto\022.\n\006"
212
      "tensor\030\010 \003(\0132\036.opencv_tensorflow.TensorP"
213
      "rotoB\007\n\005value\"\240\001\n\014NameAttrList\022\014\n\004name\030\001"
214
      " \001(\t\0227\n\004attr\030\002 \003(\0132).opencv_tensorflow.N"
215
      "ameAttrList.AttrEntry\032I\n\tAttrEntry\022\013\n\003ke"
216
      "y\030\001 \001(\t\022+\n\005value\030\002 \001(\0132\034.opencv_tensorfl"
217
      "ow.AttrValue:\0028\001B0\n\030org.tensorflow.frame"
218
      "workB\017AttrValueProtosP\001\370\001\001b\006proto3"
219
  };
220
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
221
      descriptor, 874);
222
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
223
    "attr_value.proto", &protobuf_RegisterTypes);
224
  ::protobuf_tensor_2eproto::AddDescriptors();
225
  ::protobuf_tensor_5fshape_2eproto::AddDescriptors();
226
  ::protobuf_types_2eproto::AddDescriptors();
227
}
228

229
void AddDescriptors() {
230
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
231
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
232
}
233
// Force AddDescriptors() to be called at dynamic initialization time.
234
struct StaticDescriptorInitializer {
235
  StaticDescriptorInitializer() {
236
    AddDescriptors();
237
  }
238
} static_descriptor_initializer;
239
}  // namespace protobuf_attr_5fvalue_2eproto
240
namespace opencv_tensorflow {
241

242
// ===================================================================
243

244
void AttrValue_ListValue::InitAsDefaultInstance() {
245
}
246
void AttrValue_ListValue::clear_shape() {
247
  shape_.Clear();
248
}
249
void AttrValue_ListValue::clear_tensor() {
250
  tensor_.Clear();
251
}
252
#if !defined(_MSC_VER) || _MSC_VER >= 1900
253
const int AttrValue_ListValue::kSFieldNumber;
254
const int AttrValue_ListValue::kIFieldNumber;
255
const int AttrValue_ListValue::kFFieldNumber;
256
const int AttrValue_ListValue::kBFieldNumber;
257
const int AttrValue_ListValue::kTypeFieldNumber;
258
const int AttrValue_ListValue::kShapeFieldNumber;
259
const int AttrValue_ListValue::kTensorFieldNumber;
260
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
261

262
AttrValue_ListValue::AttrValue_ListValue()
263
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
264
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
265
    ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue_ListValue();
266
  }
267
  SharedCtor();
268
  // @@protoc_insertion_point(constructor:opencv_tensorflow.AttrValue.ListValue)
269
}
270
AttrValue_ListValue::AttrValue_ListValue(::google::protobuf::Arena* arena)
271
  : ::google::protobuf::Message(),
272
  _internal_metadata_(arena),
273
  s_(arena),
274
  i_(arena),
275
  f_(arena),
276
  b_(arena),
277
  type_(arena),
278
  shape_(arena),
279
  tensor_(arena) {
280
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue_ListValue();
281
  SharedCtor();
282
  RegisterArenaDtor(arena);
283
  // @@protoc_insertion_point(arena_constructor:opencv_tensorflow.AttrValue.ListValue)
284
}
285
AttrValue_ListValue::AttrValue_ListValue(const AttrValue_ListValue& from)
286
  : ::google::protobuf::Message(),
287
      _internal_metadata_(NULL),
288
      s_(from.s_),
289
      i_(from.i_),
290
      f_(from.f_),
291
      b_(from.b_),
292
      type_(from.type_),
293
      shape_(from.shape_),
294
      tensor_(from.tensor_),
295
      _cached_size_(0) {
296
  _internal_metadata_.MergeFrom(from._internal_metadata_);
297
  // @@protoc_insertion_point(copy_constructor:opencv_tensorflow.AttrValue.ListValue)
298
}
299

300
void AttrValue_ListValue::SharedCtor() {
301
  _cached_size_ = 0;
302
}
303

304
AttrValue_ListValue::~AttrValue_ListValue() {
305
  // @@protoc_insertion_point(destructor:opencv_tensorflow.AttrValue.ListValue)
306
  SharedDtor();
307
}
308

309
void AttrValue_ListValue::SharedDtor() {
310
  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL);
311
}
312

313
void AttrValue_ListValue::ArenaDtor(void* object) {
314
  AttrValue_ListValue* _this = reinterpret_cast< AttrValue_ListValue* >(object);
315
  (void)_this;
316
}
317
void AttrValue_ListValue::RegisterArenaDtor(::google::protobuf::Arena* arena) {
318
}
319
void AttrValue_ListValue::SetCachedSize(int size) const {
320
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
321
  _cached_size_ = size;
322
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
323
}
324
const ::google::protobuf::Descriptor* AttrValue_ListValue::descriptor() {
325
  ::protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
326
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
327
}
328

329
const AttrValue_ListValue& AttrValue_ListValue::default_instance() {
330
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue_ListValue();
331
  return *internal_default_instance();
332
}
333

334
AttrValue_ListValue* AttrValue_ListValue::New(::google::protobuf::Arena* arena) const {
335
  return ::google::protobuf::Arena::CreateMessage<AttrValue_ListValue>(arena);
336
}
337

338
void AttrValue_ListValue::Clear() {
339
// @@protoc_insertion_point(message_clear_start:opencv_tensorflow.AttrValue.ListValue)
340
  ::google::protobuf::uint32 cached_has_bits = 0;
341
  // Prevent compiler warnings about cached_has_bits being unused
342
  (void) cached_has_bits;
343

344
  s_.Clear();
345
  i_.Clear();
346
  f_.Clear();
347
  b_.Clear();
348
  type_.Clear();
349
  shape_.Clear();
350
  tensor_.Clear();
351
  _internal_metadata_.Clear();
352
}
353

354
bool AttrValue_ListValue::MergePartialFromCodedStream(
355
    ::google::protobuf::io::CodedInputStream* input) {
356
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
357
  ::google::protobuf::uint32 tag;
358
  // @@protoc_insertion_point(parse_start:opencv_tensorflow.AttrValue.ListValue)
359
  for (;;) {
360
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
361
    tag = p.first;
362
    if (!p.second) goto handle_unusual;
363
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
364
      // repeated bytes s = 2;
365
      case 2: {
366
        if (static_cast< ::google::protobuf::uint8>(tag) ==
367
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
368
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
369
                input, this->add_s()));
370
        } else {
371
          goto handle_unusual;
372
        }
373
        break;
374
      }
375

376
      // repeated int64 i = 3 [packed = true];
377
      case 3: {
378
        if (static_cast< ::google::protobuf::uint8>(tag) ==
379
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
380
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
381
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
382
                 input, this->mutable_i())));
383
        } else if (
384
            static_cast< ::google::protobuf::uint8>(tag) ==
385
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
386
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
387
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
388
                 1, 26u, input, this->mutable_i())));
389
        } else {
390
          goto handle_unusual;
391
        }
392
        break;
393
      }
394

395
      // repeated float f = 4 [packed = true];
396
      case 4: {
397
        if (static_cast< ::google::protobuf::uint8>(tag) ==
398
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
399
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
400
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
401
                 input, this->mutable_f())));
402
        } else if (
403
            static_cast< ::google::protobuf::uint8>(tag) ==
404
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
405
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
406
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
407
                 1, 34u, input, this->mutable_f())));
408
        } else {
409
          goto handle_unusual;
410
        }
411
        break;
412
      }
413

414
      // repeated bool b = 5 [packed = true];
415
      case 5: {
416
        if (static_cast< ::google::protobuf::uint8>(tag) ==
417
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
418
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
419
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
420
                 input, this->mutable_b())));
421
        } else if (
422
            static_cast< ::google::protobuf::uint8>(tag) ==
423
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
424
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
425
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
426
                 1, 42u, input, this->mutable_b())));
427
        } else {
428
          goto handle_unusual;
429
        }
430
        break;
431
      }
432

433
      // repeated .opencv_tensorflow.DataType type = 6 [packed = true];
434
      case 6: {
435
        if (static_cast< ::google::protobuf::uint8>(tag) ==
436
            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {
437
          ::google::protobuf::uint32 length;
438
          DO_(input->ReadVarint32(&length));
439
          ::google::protobuf::io::CodedInputStream::Limit limit = input->PushLimit(static_cast<int>(length));
440
          while (input->BytesUntilLimit() > 0) {
441
            int value;
442
            DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
443
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
444
                 input, &value)));
445
            add_type(static_cast< ::opencv_tensorflow::DataType >(value));
446
          }
447
          input->PopLimit(limit);
448
        } else if (
449
            static_cast< ::google::protobuf::uint8>(tag) ==
450
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
451
          int value;
452
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
453
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
454
                 input, &value)));
455
          add_type(static_cast< ::opencv_tensorflow::DataType >(value));
456
        } else {
457
          goto handle_unusual;
458
        }
459
        break;
460
      }
461

462
      // repeated .opencv_tensorflow.TensorShapeProto shape = 7;
463
      case 7: {
464
        if (static_cast< ::google::protobuf::uint8>(tag) ==
465
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
466
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_shape()));
467
        } else {
468
          goto handle_unusual;
469
        }
470
        break;
471
      }
472

473
      // repeated .opencv_tensorflow.TensorProto tensor = 8;
474
      case 8: {
475
        if (static_cast< ::google::protobuf::uint8>(tag) ==
476
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
477
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_tensor()));
478
        } else {
479
          goto handle_unusual;
480
        }
481
        break;
482
      }
483

484
      default: {
485
      handle_unusual:
486
        if (tag == 0) {
487
          goto success;
488
        }
489
        DO_(::google::protobuf::internal::WireFormat::SkipField(
490
              input, tag, _internal_metadata_.mutable_unknown_fields()));
491
        break;
492
      }
493
    }
494
  }
495
success:
496
  // @@protoc_insertion_point(parse_success:opencv_tensorflow.AttrValue.ListValue)
497
  return true;
498
failure:
499
  // @@protoc_insertion_point(parse_failure:opencv_tensorflow.AttrValue.ListValue)
500
  return false;
501
#undef DO_
502
}
503

504
void AttrValue_ListValue::SerializeWithCachedSizes(
505
    ::google::protobuf::io::CodedOutputStream* output) const {
506
  // @@protoc_insertion_point(serialize_start:opencv_tensorflow.AttrValue.ListValue)
507
  ::google::protobuf::uint32 cached_has_bits = 0;
508
  (void) cached_has_bits;
509

510
  // repeated bytes s = 2;
511
  for (int i = 0, n = this->s_size(); i < n; i++) {
512
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
513
      2, this->s(i), output);
514
  }
515

516
  // repeated int64 i = 3 [packed = true];
517
  if (this->i_size() > 0) {
518
    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
519
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
520
        _i_cached_byte_size_));
521
  }
522
  for (int i = 0, n = this->i_size(); i < n; i++) {
523
    ::google::protobuf::internal::WireFormatLite::WriteInt64NoTag(
524
      this->i(i), output);
525
  }
526

527
  // repeated float f = 4 [packed = true];
528
  if (this->f_size() > 0) {
529
    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
530
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
531
        _f_cached_byte_size_));
532
    ::google::protobuf::internal::WireFormatLite::WriteFloatArray(
533
      this->f().data(), this->f_size(), output);
534
  }
535

536
  // repeated bool b = 5 [packed = true];
537
  if (this->b_size() > 0) {
538
    ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
539
    output->WriteVarint32(static_cast< ::google::protobuf::uint32>(
540
        _b_cached_byte_size_));
541
    ::google::protobuf::internal::WireFormatLite::WriteBoolArray(
542
      this->b().data(), this->b_size(), output);
543
  }
544

545
  // repeated .opencv_tensorflow.DataType type = 6 [packed = true];
546
  if (this->type_size() > 0) {
547
    ::google::protobuf::internal::WireFormatLite::WriteTag(
548
      6,
549
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
550
      output);
551
    output->WriteVarint32(
552
        static_cast< ::google::protobuf::uint32>(_type_cached_byte_size_));
553
  }
554
  for (int i = 0, n = this->type_size(); i < n; i++) {
555
    ::google::protobuf::internal::WireFormatLite::WriteEnumNoTag(
556
      this->type(i), output);
557
  }
558

559
  // repeated .opencv_tensorflow.TensorShapeProto shape = 7;
560
  for (unsigned int i = 0,
561
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
562
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
563
      7, this->shape(static_cast<int>(i)), output);
564
  }
565

566
  // repeated .opencv_tensorflow.TensorProto tensor = 8;
567
  for (unsigned int i = 0,
568
      n = static_cast<unsigned int>(this->tensor_size()); i < n; i++) {
569
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
570
      8, this->tensor(static_cast<int>(i)), output);
571
  }
572

573
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
574
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
575
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
576
  }
577
  // @@protoc_insertion_point(serialize_end:opencv_tensorflow.AttrValue.ListValue)
578
}
579

580
::google::protobuf::uint8* AttrValue_ListValue::InternalSerializeWithCachedSizesToArray(
581
    bool deterministic, ::google::protobuf::uint8* target) const {
582
  (void)deterministic; // Unused
583
  // @@protoc_insertion_point(serialize_to_array_start:opencv_tensorflow.AttrValue.ListValue)
584
  ::google::protobuf::uint32 cached_has_bits = 0;
585
  (void) cached_has_bits;
586

587
  // repeated bytes s = 2;
588
  for (int i = 0, n = this->s_size(); i < n; i++) {
589
    target = ::google::protobuf::internal::WireFormatLite::
590
      WriteBytesToArray(2, this->s(i), target);
591
  }
592

593
  // repeated int64 i = 3 [packed = true];
594
  if (this->i_size() > 0) {
595
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
596
      3,
597
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
598
      target);
599
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
600
        static_cast< ::google::protobuf::int32>(
601
            _i_cached_byte_size_), target);
602
    target = ::google::protobuf::internal::WireFormatLite::
603
      WriteInt64NoTagToArray(this->i_, target);
604
  }
605

606
  // repeated float f = 4 [packed = true];
607
  if (this->f_size() > 0) {
608
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
609
      4,
610
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
611
      target);
612
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
613
        static_cast< ::google::protobuf::int32>(
614
            _f_cached_byte_size_), target);
615
    target = ::google::protobuf::internal::WireFormatLite::
616
      WriteFloatNoTagToArray(this->f_, target);
617
  }
618

619
  // repeated bool b = 5 [packed = true];
620
  if (this->b_size() > 0) {
621
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
622
      5,
623
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
624
      target);
625
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
626
        static_cast< ::google::protobuf::int32>(
627
            _b_cached_byte_size_), target);
628
    target = ::google::protobuf::internal::WireFormatLite::
629
      WriteBoolNoTagToArray(this->b_, target);
630
  }
631

632
  // repeated .opencv_tensorflow.DataType type = 6 [packed = true];
633
  if (this->type_size() > 0) {
634
    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
635
      6,
636
      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
637
      target);
638
    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(      static_cast< ::google::protobuf::uint32>(
639
            _type_cached_byte_size_), target);
640
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumNoTagToArray(
641
      this->type_, target);
642
  }
643

644
  // repeated .opencv_tensorflow.TensorShapeProto shape = 7;
645
  for (unsigned int i = 0,
646
      n = static_cast<unsigned int>(this->shape_size()); i < n; i++) {
647
    target = ::google::protobuf::internal::WireFormatLite::
648
      InternalWriteMessageToArray(
649
        7, this->shape(static_cast<int>(i)), deterministic, target);
650
  }
651

652
  // repeated .opencv_tensorflow.TensorProto tensor = 8;
653
  for (unsigned int i = 0,
654
      n = static_cast<unsigned int>(this->tensor_size()); i < n; i++) {
655
    target = ::google::protobuf::internal::WireFormatLite::
656
      InternalWriteMessageToArray(
657
        8, this->tensor(static_cast<int>(i)), deterministic, target);
658
  }
659

660
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
661
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
662
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
663
  }
664
  // @@protoc_insertion_point(serialize_to_array_end:opencv_tensorflow.AttrValue.ListValue)
665
  return target;
666
}
667

668
size_t AttrValue_ListValue::ByteSizeLong() const {
669
// @@protoc_insertion_point(message_byte_size_start:opencv_tensorflow.AttrValue.ListValue)
670
  size_t total_size = 0;
671

672
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
673
    total_size +=
674
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
675
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
676
  }
677
  // repeated bytes s = 2;
678
  total_size += 1 *
679
      ::google::protobuf::internal::FromIntSize(this->s_size());
680
  for (int i = 0, n = this->s_size(); i < n; i++) {
681
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
682
      this->s(i));
683
  }
684

685
  // repeated int64 i = 3 [packed = true];
686
  {
687
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
688
      Int64Size(this->i_);
689
    if (data_size > 0) {
690
      total_size += 1 +
691
        ::google::protobuf::internal::WireFormatLite::Int32Size(
692
            static_cast< ::google::protobuf::int32>(data_size));
693
    }
694
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
695
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
696
    _i_cached_byte_size_ = cached_size;
697
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
698
    total_size += data_size;
699
  }
700

701
  // repeated float f = 4 [packed = true];
702
  {
703
    unsigned int count = static_cast<unsigned int>(this->f_size());
704
    size_t data_size = 4UL * count;
705
    if (data_size > 0) {
706
      total_size += 1 +
707
        ::google::protobuf::internal::WireFormatLite::Int32Size(
708
            static_cast< ::google::protobuf::int32>(data_size));
709
    }
710
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
711
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
712
    _f_cached_byte_size_ = cached_size;
713
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
714
    total_size += data_size;
715
  }
716

717
  // repeated bool b = 5 [packed = true];
718
  {
719
    unsigned int count = static_cast<unsigned int>(this->b_size());
720
    size_t data_size = 1UL * count;
721
    if (data_size > 0) {
722
      total_size += 1 +
723
        ::google::protobuf::internal::WireFormatLite::Int32Size(
724
            static_cast< ::google::protobuf::int32>(data_size));
725
    }
726
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
727
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
728
    _b_cached_byte_size_ = cached_size;
729
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
730
    total_size += data_size;
731
  }
732

733
  // repeated .opencv_tensorflow.DataType type = 6 [packed = true];
734
  {
735
    size_t data_size = 0;
736
    unsigned int count = static_cast<unsigned int>(this->type_size());for (unsigned int i = 0; i < count; i++) {
737
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
738
        this->type(static_cast<int>(i)));
739
    }
740
    if (data_size > 0) {
741
      total_size += 1 +
742
        ::google::protobuf::internal::WireFormatLite::Int32Size(
743
            static_cast< ::google::protobuf::int32>(data_size));
744
    }
745
    int cached_size = ::google::protobuf::internal::ToCachedSize(data_size);
746
    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
747
    _type_cached_byte_size_ = cached_size;
748
    GOOGLE_SAFE_CONCURRENT_WRITES_END();
749
    total_size += data_size;
750
  }
751

752
  // repeated .opencv_tensorflow.TensorShapeProto shape = 7;
753
  {
754
    unsigned int count = static_cast<unsigned int>(this->shape_size());
755
    total_size += 1UL * count;
756
    for (unsigned int i = 0; i < count; i++) {
757
      total_size +=
758
        ::google::protobuf::internal::WireFormatLite::MessageSize(
759
          this->shape(static_cast<int>(i)));
760
    }
761
  }
762

763
  // repeated .opencv_tensorflow.TensorProto tensor = 8;
764
  {
765
    unsigned int count = static_cast<unsigned int>(this->tensor_size());
766
    total_size += 1UL * count;
767
    for (unsigned int i = 0; i < count; i++) {
768
      total_size +=
769
        ::google::protobuf::internal::WireFormatLite::MessageSize(
770
          this->tensor(static_cast<int>(i)));
771
    }
772
  }
773

774
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
775
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
776
  _cached_size_ = cached_size;
777
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
778
  return total_size;
779
}
780

781
void AttrValue_ListValue::MergeFrom(const ::google::protobuf::Message& from) {
782
// @@protoc_insertion_point(generalized_merge_from_start:opencv_tensorflow.AttrValue.ListValue)
783
  GOOGLE_DCHECK_NE(&from, this);
784
  const AttrValue_ListValue* source =
785
      ::google::protobuf::internal::DynamicCastToGenerated<const AttrValue_ListValue>(
786
          &from);
787
  if (source == NULL) {
788
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_tensorflow.AttrValue.ListValue)
789
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
790
  } else {
791
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_tensorflow.AttrValue.ListValue)
792
    MergeFrom(*source);
793
  }
794
}
795

796
void AttrValue_ListValue::MergeFrom(const AttrValue_ListValue& from) {
797
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_tensorflow.AttrValue.ListValue)
798
  GOOGLE_DCHECK_NE(&from, this);
799
  _internal_metadata_.MergeFrom(from._internal_metadata_);
800
  ::google::protobuf::uint32 cached_has_bits = 0;
801
  (void) cached_has_bits;
802

803
  s_.MergeFrom(from.s_);
804
  i_.MergeFrom(from.i_);
805
  f_.MergeFrom(from.f_);
806
  b_.MergeFrom(from.b_);
807
  type_.MergeFrom(from.type_);
808
  shape_.MergeFrom(from.shape_);
809
  tensor_.MergeFrom(from.tensor_);
810
}
811

812
void AttrValue_ListValue::CopyFrom(const ::google::protobuf::Message& from) {
813
// @@protoc_insertion_point(generalized_copy_from_start:opencv_tensorflow.AttrValue.ListValue)
814
  if (&from == this) return;
815
  Clear();
816
  MergeFrom(from);
817
}
818

819
void AttrValue_ListValue::CopyFrom(const AttrValue_ListValue& from) {
820
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_tensorflow.AttrValue.ListValue)
821
  if (&from == this) return;
822
  Clear();
823
  MergeFrom(from);
824
}
825

826
bool AttrValue_ListValue::IsInitialized() const {
827
  return true;
828
}
829

830
void AttrValue_ListValue::Swap(AttrValue_ListValue* other) {
831
  if (other == this) return;
832
  if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
833
    InternalSwap(other);
834
  } else {
835
    AttrValue_ListValue* temp = New(GetArenaNoVirtual());
836
    temp->MergeFrom(*other);
837
    other->CopyFrom(*this);
838
    InternalSwap(temp);
839
    if (GetArenaNoVirtual() == NULL) {
840
      delete temp;
841
    }
842
  }
843
}
844
void AttrValue_ListValue::UnsafeArenaSwap(AttrValue_ListValue* other) {
845
  if (other == this) return;
846
  GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
847
  InternalSwap(other);
848
}
849
void AttrValue_ListValue::InternalSwap(AttrValue_ListValue* other) {
850
  using std::swap;
851
  s_.InternalSwap(&other->s_);
852
  i_.InternalSwap(&other->i_);
853
  f_.InternalSwap(&other->f_);
854
  b_.InternalSwap(&other->b_);
855
  type_.InternalSwap(&other->type_);
856
  shape_.InternalSwap(&other->shape_);
857
  tensor_.InternalSwap(&other->tensor_);
858
  _internal_metadata_.Swap(&other->_internal_metadata_);
859
  swap(_cached_size_, other->_cached_size_);
860
}
861

862
::google::protobuf::Metadata AttrValue_ListValue::GetMetadata() const {
863
  protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
864
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages];
865
}
866

867

868
// ===================================================================
869

870
void AttrValue::InitAsDefaultInstance() {
871
  ::opencv_tensorflow::_AttrValue_default_instance_.s_.UnsafeSetDefault(
872
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
873
  ::opencv_tensorflow::_AttrValue_default_instance_.i_ = GOOGLE_LONGLONG(0);
874
  ::opencv_tensorflow::_AttrValue_default_instance_.f_ = 0;
875
  ::opencv_tensorflow::_AttrValue_default_instance_.b_ = false;
876
  ::opencv_tensorflow::_AttrValue_default_instance_.type_ = 0;
877
  ::opencv_tensorflow::_AttrValue_default_instance_.shape_ = const_cast< ::opencv_tensorflow::TensorShapeProto*>(
878
      ::opencv_tensorflow::TensorShapeProto::internal_default_instance());
879
  ::opencv_tensorflow::_AttrValue_default_instance_.tensor_ = const_cast< ::opencv_tensorflow::TensorProto*>(
880
      ::opencv_tensorflow::TensorProto::internal_default_instance());
881
  ::opencv_tensorflow::_AttrValue_default_instance_.list_ = const_cast< ::opencv_tensorflow::AttrValue_ListValue*>(
882
      ::opencv_tensorflow::AttrValue_ListValue::internal_default_instance());
883
  ::opencv_tensorflow::_AttrValue_default_instance_.func_ = const_cast< ::opencv_tensorflow::NameAttrList*>(
884
      ::opencv_tensorflow::NameAttrList::internal_default_instance());
885
  ::opencv_tensorflow::_AttrValue_default_instance_.placeholder_.UnsafeSetDefault(
886
      &::google::protobuf::internal::GetEmptyStringAlreadyInited());
887
}
888
void AttrValue::set_allocated_shape(::opencv_tensorflow::TensorShapeProto* shape) {
889
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
890
  clear_value();
891
  if (shape) {
892
    ::google::protobuf::Arena* submessage_arena =
893
      reinterpret_cast< ::google::protobuf::MessageLite*>(shape)->GetArena();
894
    if (message_arena != submessage_arena) {
895
      shape = ::google::protobuf::internal::GetOwnedMessage(
896
          message_arena, shape, submessage_arena);
897
    }
898
    set_has_shape();
899
    value_.shape_ = shape;
900
  }
901
  // @@protoc_insertion_point(field_set_allocated:opencv_tensorflow.AttrValue.shape)
902
}
903
void AttrValue::clear_shape() {
904
  if (has_shape()) {
905
    if (GetArenaNoVirtual() == NULL) {
906
      delete value_.shape_;
907
    }
908
    clear_has_value();
909
  }
910
}
911
void AttrValue::set_allocated_tensor(::opencv_tensorflow::TensorProto* tensor) {
912
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
913
  clear_value();
914
  if (tensor) {
915
    ::google::protobuf::Arena* submessage_arena =
916
      reinterpret_cast< ::google::protobuf::MessageLite*>(tensor)->GetArena();
917
    if (message_arena != submessage_arena) {
918
      tensor = ::google::protobuf::internal::GetOwnedMessage(
919
          message_arena, tensor, submessage_arena);
920
    }
921
    set_has_tensor();
922
    value_.tensor_ = tensor;
923
  }
924
  // @@protoc_insertion_point(field_set_allocated:opencv_tensorflow.AttrValue.tensor)
925
}
926
void AttrValue::clear_tensor() {
927
  if (has_tensor()) {
928
    if (GetArenaNoVirtual() == NULL) {
929
      delete value_.tensor_;
930
    }
931
    clear_has_value();
932
  }
933
}
934
void AttrValue::set_allocated_list(::opencv_tensorflow::AttrValue_ListValue* list) {
935
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
936
  clear_value();
937
  if (list) {
938
    ::google::protobuf::Arena* submessage_arena =
939
      ::google::protobuf::Arena::GetArena(list);
940
    if (message_arena != submessage_arena) {
941
      list = ::google::protobuf::internal::GetOwnedMessage(
942
          message_arena, list, submessage_arena);
943
    }
944
    set_has_list();
945
    value_.list_ = list;
946
  }
947
  // @@protoc_insertion_point(field_set_allocated:opencv_tensorflow.AttrValue.list)
948
}
949
void AttrValue::set_allocated_func(::opencv_tensorflow::NameAttrList* func) {
950
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
951
  clear_value();
952
  if (func) {
953
    ::google::protobuf::Arena* submessage_arena =
954
      ::google::protobuf::Arena::GetArena(func);
955
    if (message_arena != submessage_arena) {
956
      func = ::google::protobuf::internal::GetOwnedMessage(
957
          message_arena, func, submessage_arena);
958
    }
959
    set_has_func();
960
    value_.func_ = func;
961
  }
962
  // @@protoc_insertion_point(field_set_allocated:opencv_tensorflow.AttrValue.func)
963
}
964
#if !defined(_MSC_VER) || _MSC_VER >= 1900
965
const int AttrValue::kSFieldNumber;
966
const int AttrValue::kIFieldNumber;
967
const int AttrValue::kFFieldNumber;
968
const int AttrValue::kBFieldNumber;
969
const int AttrValue::kTypeFieldNumber;
970
const int AttrValue::kShapeFieldNumber;
971
const int AttrValue::kTensorFieldNumber;
972
const int AttrValue::kListFieldNumber;
973
const int AttrValue::kFuncFieldNumber;
974
const int AttrValue::kPlaceholderFieldNumber;
975
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
976

977
AttrValue::AttrValue()
978
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
979
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
980
    ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
981
  }
982
  SharedCtor();
983
  // @@protoc_insertion_point(constructor:opencv_tensorflow.AttrValue)
984
}
985
AttrValue::AttrValue(::google::protobuf::Arena* arena)
986
  : ::google::protobuf::Message(),
987
  _internal_metadata_(arena) {
988
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
989
  SharedCtor();
990
  RegisterArenaDtor(arena);
991
  // @@protoc_insertion_point(arena_constructor:opencv_tensorflow.AttrValue)
992
}
993
AttrValue::AttrValue(const AttrValue& from)
994
  : ::google::protobuf::Message(),
995
      _internal_metadata_(NULL),
996
      _cached_size_(0) {
997
  _internal_metadata_.MergeFrom(from._internal_metadata_);
998
  clear_has_value();
999
  switch (from.value_case()) {
1000
    case kS: {
1001
      set_s(from.s());
1002
      break;
1003
    }
1004
    case kI: {
1005
      set_i(from.i());
1006
      break;
1007
    }
1008
    case kF: {
1009
      set_f(from.f());
1010
      break;
1011
    }
1012
    case kB: {
1013
      set_b(from.b());
1014
      break;
1015
    }
1016
    case kType: {
1017
      set_type(from.type());
1018
      break;
1019
    }
1020
    case kShape: {
1021
      mutable_shape()->::opencv_tensorflow::TensorShapeProto::MergeFrom(from.shape());
1022
      break;
1023
    }
1024
    case kTensor: {
1025
      mutable_tensor()->::opencv_tensorflow::TensorProto::MergeFrom(from.tensor());
1026
      break;
1027
    }
1028
    case kList: {
1029
      mutable_list()->::opencv_tensorflow::AttrValue_ListValue::MergeFrom(from.list());
1030
      break;
1031
    }
1032
    case kFunc: {
1033
      mutable_func()->::opencv_tensorflow::NameAttrList::MergeFrom(from.func());
1034
      break;
1035
    }
1036
    case kPlaceholder: {
1037
      set_placeholder(from.placeholder());
1038
      break;
1039
    }
1040
    case VALUE_NOT_SET: {
1041
      break;
1042
    }
1043
  }
1044
  // @@protoc_insertion_point(copy_constructor:opencv_tensorflow.AttrValue)
1045
}
1046

1047
void AttrValue::SharedCtor() {
1048
  clear_has_value();
1049
  _cached_size_ = 0;
1050
}
1051

1052
AttrValue::~AttrValue() {
1053
  // @@protoc_insertion_point(destructor:opencv_tensorflow.AttrValue)
1054
  SharedDtor();
1055
}
1056

1057
void AttrValue::SharedDtor() {
1058
  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL);
1059
  if (has_value()) {
1060
    clear_value();
1061
  }
1062
}
1063

1064
void AttrValue::ArenaDtor(void* object) {
1065
  AttrValue* _this = reinterpret_cast< AttrValue* >(object);
1066
  (void)_this;
1067
}
1068
void AttrValue::RegisterArenaDtor(::google::protobuf::Arena* arena) {
1069
}
1070
void AttrValue::SetCachedSize(int size) const {
1071
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1072
  _cached_size_ = size;
1073
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
1074
}
1075
const ::google::protobuf::Descriptor* AttrValue::descriptor() {
1076
  ::protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
1077
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1078
}
1079

1080
const AttrValue& AttrValue::default_instance() {
1081
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
1082
  return *internal_default_instance();
1083
}
1084

1085
AttrValue* AttrValue::New(::google::protobuf::Arena* arena) const {
1086
  return ::google::protobuf::Arena::CreateMessage<AttrValue>(arena);
1087
}
1088

1089
void AttrValue::clear_value() {
1090
// @@protoc_insertion_point(one_of_clear_start:opencv_tensorflow.AttrValue)
1091
  switch (value_case()) {
1092
    case kS: {
1093
      value_.s_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1094
          GetArenaNoVirtual());
1095
      break;
1096
    }
1097
    case kI: {
1098
      // No need to clear
1099
      break;
1100
    }
1101
    case kF: {
1102
      // No need to clear
1103
      break;
1104
    }
1105
    case kB: {
1106
      // No need to clear
1107
      break;
1108
    }
1109
    case kType: {
1110
      // No need to clear
1111
      break;
1112
    }
1113
    case kShape: {
1114
      if (GetArenaNoVirtual() == NULL) {
1115
        delete value_.shape_;
1116
      }
1117
      break;
1118
    }
1119
    case kTensor: {
1120
      if (GetArenaNoVirtual() == NULL) {
1121
        delete value_.tensor_;
1122
      }
1123
      break;
1124
    }
1125
    case kList: {
1126
      if (GetArenaNoVirtual() == NULL) {
1127
        delete value_.list_;
1128
      }
1129
      break;
1130
    }
1131
    case kFunc: {
1132
      if (GetArenaNoVirtual() == NULL) {
1133
        delete value_.func_;
1134
      }
1135
      break;
1136
    }
1137
    case kPlaceholder: {
1138
      value_.placeholder_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
1139
          GetArenaNoVirtual());
1140
      break;
1141
    }
1142
    case VALUE_NOT_SET: {
1143
      break;
1144
    }
1145
  }
1146
  _oneof_case_[0] = VALUE_NOT_SET;
1147
}
1148

1149

1150
void AttrValue::Clear() {
1151
// @@protoc_insertion_point(message_clear_start:opencv_tensorflow.AttrValue)
1152
  ::google::protobuf::uint32 cached_has_bits = 0;
1153
  // Prevent compiler warnings about cached_has_bits being unused
1154
  (void) cached_has_bits;
1155

1156
  clear_value();
1157
  _internal_metadata_.Clear();
1158
}
1159

1160
bool AttrValue::MergePartialFromCodedStream(
1161
    ::google::protobuf::io::CodedInputStream* input) {
1162
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1163
  ::google::protobuf::uint32 tag;
1164
  // @@protoc_insertion_point(parse_start:opencv_tensorflow.AttrValue)
1165
  for (;;) {
1166
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1167
    tag = p.first;
1168
    if (!p.second) goto handle_unusual;
1169
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1170
      // .opencv_tensorflow.AttrValue.ListValue list = 1;
1171
      case 1: {
1172
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1173
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
1174
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1175
               input, mutable_list()));
1176
        } else {
1177
          goto handle_unusual;
1178
        }
1179
        break;
1180
      }
1181

1182
      // bytes s = 2;
1183
      case 2: {
1184
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1185
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1186
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
1187
                input, this->mutable_s()));
1188
        } else {
1189
          goto handle_unusual;
1190
        }
1191
        break;
1192
      }
1193

1194
      // int64 i = 3;
1195
      case 3: {
1196
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1197
            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {
1198
          clear_value();
1199
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1200
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
1201
                 input, &value_.i_)));
1202
          set_has_i();
1203
        } else {
1204
          goto handle_unusual;
1205
        }
1206
        break;
1207
      }
1208

1209
      // float f = 4;
1210
      case 4: {
1211
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1212
            static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) {
1213
          clear_value();
1214
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1215
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
1216
                 input, &value_.f_)));
1217
          set_has_f();
1218
        } else {
1219
          goto handle_unusual;
1220
        }
1221
        break;
1222
      }
1223

1224
      // bool b = 5;
1225
      case 5: {
1226
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1227
            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {
1228
          clear_value();
1229
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1230
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
1231
                 input, &value_.b_)));
1232
          set_has_b();
1233
        } else {
1234
          goto handle_unusual;
1235
        }
1236
        break;
1237
      }
1238

1239
      // .opencv_tensorflow.DataType type = 6;
1240
      case 6: {
1241
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1242
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
1243
          int value;
1244
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1245
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
1246
                 input, &value)));
1247
          set_type(static_cast< ::opencv_tensorflow::DataType >(value));
1248
        } else {
1249
          goto handle_unusual;
1250
        }
1251
        break;
1252
      }
1253

1254
      // .opencv_tensorflow.TensorShapeProto shape = 7;
1255
      case 7: {
1256
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1257
            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {
1258
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1259
               input, mutable_shape()));
1260
        } else {
1261
          goto handle_unusual;
1262
        }
1263
        break;
1264
      }
1265

1266
      // .opencv_tensorflow.TensorProto tensor = 8;
1267
      case 8: {
1268
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1269
            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {
1270
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1271
               input, mutable_tensor()));
1272
        } else {
1273
          goto handle_unusual;
1274
        }
1275
        break;
1276
      }
1277

1278
      // string placeholder = 9;
1279
      case 9: {
1280
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1281
            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {
1282
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1283
                input, this->mutable_placeholder()));
1284
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1285
            this->placeholder().data(), static_cast<int>(this->placeholder().length()),
1286
            ::google::protobuf::internal::WireFormatLite::PARSE,
1287
            "opencv_tensorflow.AttrValue.placeholder"));
1288
        } else {
1289
          goto handle_unusual;
1290
        }
1291
        break;
1292
      }
1293

1294
      // .opencv_tensorflow.NameAttrList func = 10;
1295
      case 10: {
1296
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1297
            static_cast< ::google::protobuf::uint8>(82u /* 82 & 0xFF */)) {
1298
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
1299
               input, mutable_func()));
1300
        } else {
1301
          goto handle_unusual;
1302
        }
1303
        break;
1304
      }
1305

1306
      default: {
1307
      handle_unusual:
1308
        if (tag == 0) {
1309
          goto success;
1310
        }
1311
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1312
              input, tag, _internal_metadata_.mutable_unknown_fields()));
1313
        break;
1314
      }
1315
    }
1316
  }
1317
success:
1318
  // @@protoc_insertion_point(parse_success:opencv_tensorflow.AttrValue)
1319
  return true;
1320
failure:
1321
  // @@protoc_insertion_point(parse_failure:opencv_tensorflow.AttrValue)
1322
  return false;
1323
#undef DO_
1324
}
1325

1326
void AttrValue::SerializeWithCachedSizes(
1327
    ::google::protobuf::io::CodedOutputStream* output) const {
1328
  // @@protoc_insertion_point(serialize_start:opencv_tensorflow.AttrValue)
1329
  ::google::protobuf::uint32 cached_has_bits = 0;
1330
  (void) cached_has_bits;
1331

1332
  // .opencv_tensorflow.AttrValue.ListValue list = 1;
1333
  if (has_list()) {
1334
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1335
      1, *value_.list_, output);
1336
  }
1337

1338
  // bytes s = 2;
1339
  if (has_s()) {
1340
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
1341
      2, this->s(), output);
1342
  }
1343

1344
  // int64 i = 3;
1345
  if (has_i()) {
1346
    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->i(), output);
1347
  }
1348

1349
  // float f = 4;
1350
  if (has_f()) {
1351
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->f(), output);
1352
  }
1353

1354
  // bool b = 5;
1355
  if (has_b()) {
1356
    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->b(), output);
1357
  }
1358

1359
  // .opencv_tensorflow.DataType type = 6;
1360
  if (has_type()) {
1361
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
1362
      6, this->type(), output);
1363
  }
1364

1365
  // .opencv_tensorflow.TensorShapeProto shape = 7;
1366
  if (has_shape()) {
1367
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1368
      7, *value_.shape_, output);
1369
  }
1370

1371
  // .opencv_tensorflow.TensorProto tensor = 8;
1372
  if (has_tensor()) {
1373
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1374
      8, *value_.tensor_, output);
1375
  }
1376

1377
  // string placeholder = 9;
1378
  if (has_placeholder()) {
1379
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1380
      this->placeholder().data(), static_cast<int>(this->placeholder().length()),
1381
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1382
      "opencv_tensorflow.AttrValue.placeholder");
1383
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1384
      9, this->placeholder(), output);
1385
  }
1386

1387
  // .opencv_tensorflow.NameAttrList func = 10;
1388
  if (has_func()) {
1389
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1390
      10, *value_.func_, output);
1391
  }
1392

1393
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
1394
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1395
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
1396
  }
1397
  // @@protoc_insertion_point(serialize_end:opencv_tensorflow.AttrValue)
1398
}
1399

1400
::google::protobuf::uint8* AttrValue::InternalSerializeWithCachedSizesToArray(
1401
    bool deterministic, ::google::protobuf::uint8* target) const {
1402
  (void)deterministic; // Unused
1403
  // @@protoc_insertion_point(serialize_to_array_start:opencv_tensorflow.AttrValue)
1404
  ::google::protobuf::uint32 cached_has_bits = 0;
1405
  (void) cached_has_bits;
1406

1407
  // .opencv_tensorflow.AttrValue.ListValue list = 1;
1408
  if (has_list()) {
1409
    target = ::google::protobuf::internal::WireFormatLite::
1410
      InternalWriteMessageToArray(
1411
        1, *value_.list_, deterministic, target);
1412
  }
1413

1414
  // bytes s = 2;
1415
  if (has_s()) {
1416
    target =
1417
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
1418
        2, this->s(), target);
1419
  }
1420

1421
  // int64 i = 3;
1422
  if (has_i()) {
1423
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->i(), target);
1424
  }
1425

1426
  // float f = 4;
1427
  if (has_f()) {
1428
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->f(), target);
1429
  }
1430

1431
  // bool b = 5;
1432
  if (has_b()) {
1433
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->b(), target);
1434
  }
1435

1436
  // .opencv_tensorflow.DataType type = 6;
1437
  if (has_type()) {
1438
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
1439
      6, this->type(), target);
1440
  }
1441

1442
  // .opencv_tensorflow.TensorShapeProto shape = 7;
1443
  if (has_shape()) {
1444
    target = ::google::protobuf::internal::WireFormatLite::
1445
      InternalWriteMessageToArray(
1446
        7, *value_.shape_, deterministic, target);
1447
  }
1448

1449
  // .opencv_tensorflow.TensorProto tensor = 8;
1450
  if (has_tensor()) {
1451
    target = ::google::protobuf::internal::WireFormatLite::
1452
      InternalWriteMessageToArray(
1453
        8, *value_.tensor_, deterministic, target);
1454
  }
1455

1456
  // string placeholder = 9;
1457
  if (has_placeholder()) {
1458
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1459
      this->placeholder().data(), static_cast<int>(this->placeholder().length()),
1460
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1461
      "opencv_tensorflow.AttrValue.placeholder");
1462
    target =
1463
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1464
        9, this->placeholder(), target);
1465
  }
1466

1467
  // .opencv_tensorflow.NameAttrList func = 10;
1468
  if (has_func()) {
1469
    target = ::google::protobuf::internal::WireFormatLite::
1470
      InternalWriteMessageToArray(
1471
        10, *value_.func_, deterministic, target);
1472
  }
1473

1474
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
1475
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1476
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
1477
  }
1478
  // @@protoc_insertion_point(serialize_to_array_end:opencv_tensorflow.AttrValue)
1479
  return target;
1480
}
1481

1482
size_t AttrValue::ByteSizeLong() const {
1483
// @@protoc_insertion_point(message_byte_size_start:opencv_tensorflow.AttrValue)
1484
  size_t total_size = 0;
1485

1486
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
1487
    total_size +=
1488
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1489
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
1490
  }
1491
  switch (value_case()) {
1492
    // bytes s = 2;
1493
    case kS: {
1494
      total_size += 1 +
1495
        ::google::protobuf::internal::WireFormatLite::BytesSize(
1496
          this->s());
1497
      break;
1498
    }
1499
    // int64 i = 3;
1500
    case kI: {
1501
      total_size += 1 +
1502
        ::google::protobuf::internal::WireFormatLite::Int64Size(
1503
          this->i());
1504
      break;
1505
    }
1506
    // float f = 4;
1507
    case kF: {
1508
      total_size += 1 + 4;
1509
      break;
1510
    }
1511
    // bool b = 5;
1512
    case kB: {
1513
      total_size += 1 + 1;
1514
      break;
1515
    }
1516
    // .opencv_tensorflow.DataType type = 6;
1517
    case kType: {
1518
      total_size += 1 +
1519
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
1520
      break;
1521
    }
1522
    // .opencv_tensorflow.TensorShapeProto shape = 7;
1523
    case kShape: {
1524
      total_size += 1 +
1525
        ::google::protobuf::internal::WireFormatLite::MessageSize(
1526
          *value_.shape_);
1527
      break;
1528
    }
1529
    // .opencv_tensorflow.TensorProto tensor = 8;
1530
    case kTensor: {
1531
      total_size += 1 +
1532
        ::google::protobuf::internal::WireFormatLite::MessageSize(
1533
          *value_.tensor_);
1534
      break;
1535
    }
1536
    // .opencv_tensorflow.AttrValue.ListValue list = 1;
1537
    case kList: {
1538
      total_size += 1 +
1539
        ::google::protobuf::internal::WireFormatLite::MessageSize(
1540
          *value_.list_);
1541
      break;
1542
    }
1543
    // .opencv_tensorflow.NameAttrList func = 10;
1544
    case kFunc: {
1545
      total_size += 1 +
1546
        ::google::protobuf::internal::WireFormatLite::MessageSize(
1547
          *value_.func_);
1548
      break;
1549
    }
1550
    // string placeholder = 9;
1551
    case kPlaceholder: {
1552
      total_size += 1 +
1553
        ::google::protobuf::internal::WireFormatLite::StringSize(
1554
          this->placeholder());
1555
      break;
1556
    }
1557
    case VALUE_NOT_SET: {
1558
      break;
1559
    }
1560
  }
1561
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
1562
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1563
  _cached_size_ = cached_size;
1564
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
1565
  return total_size;
1566
}
1567

1568
void AttrValue::MergeFrom(const ::google::protobuf::Message& from) {
1569
// @@protoc_insertion_point(generalized_merge_from_start:opencv_tensorflow.AttrValue)
1570
  GOOGLE_DCHECK_NE(&from, this);
1571
  const AttrValue* source =
1572
      ::google::protobuf::internal::DynamicCastToGenerated<const AttrValue>(
1573
          &from);
1574
  if (source == NULL) {
1575
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_tensorflow.AttrValue)
1576
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1577
  } else {
1578
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_tensorflow.AttrValue)
1579
    MergeFrom(*source);
1580
  }
1581
}
1582

1583
void AttrValue::MergeFrom(const AttrValue& from) {
1584
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_tensorflow.AttrValue)
1585
  GOOGLE_DCHECK_NE(&from, this);
1586
  _internal_metadata_.MergeFrom(from._internal_metadata_);
1587
  ::google::protobuf::uint32 cached_has_bits = 0;
1588
  (void) cached_has_bits;
1589

1590
  switch (from.value_case()) {
1591
    case kS: {
1592
      set_s(from.s());
1593
      break;
1594
    }
1595
    case kI: {
1596
      set_i(from.i());
1597
      break;
1598
    }
1599
    case kF: {
1600
      set_f(from.f());
1601
      break;
1602
    }
1603
    case kB: {
1604
      set_b(from.b());
1605
      break;
1606
    }
1607
    case kType: {
1608
      set_type(from.type());
1609
      break;
1610
    }
1611
    case kShape: {
1612
      mutable_shape()->::opencv_tensorflow::TensorShapeProto::MergeFrom(from.shape());
1613
      break;
1614
    }
1615
    case kTensor: {
1616
      mutable_tensor()->::opencv_tensorflow::TensorProto::MergeFrom(from.tensor());
1617
      break;
1618
    }
1619
    case kList: {
1620
      mutable_list()->::opencv_tensorflow::AttrValue_ListValue::MergeFrom(from.list());
1621
      break;
1622
    }
1623
    case kFunc: {
1624
      mutable_func()->::opencv_tensorflow::NameAttrList::MergeFrom(from.func());
1625
      break;
1626
    }
1627
    case kPlaceholder: {
1628
      set_placeholder(from.placeholder());
1629
      break;
1630
    }
1631
    case VALUE_NOT_SET: {
1632
      break;
1633
    }
1634
  }
1635
}
1636

1637
void AttrValue::CopyFrom(const ::google::protobuf::Message& from) {
1638
// @@protoc_insertion_point(generalized_copy_from_start:opencv_tensorflow.AttrValue)
1639
  if (&from == this) return;
1640
  Clear();
1641
  MergeFrom(from);
1642
}
1643

1644
void AttrValue::CopyFrom(const AttrValue& from) {
1645
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_tensorflow.AttrValue)
1646
  if (&from == this) return;
1647
  Clear();
1648
  MergeFrom(from);
1649
}
1650

1651
bool AttrValue::IsInitialized() const {
1652
  return true;
1653
}
1654

1655
void AttrValue::Swap(AttrValue* other) {
1656
  if (other == this) return;
1657
  if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1658
    InternalSwap(other);
1659
  } else {
1660
    AttrValue* temp = New(GetArenaNoVirtual());
1661
    temp->MergeFrom(*other);
1662
    other->CopyFrom(*this);
1663
    InternalSwap(temp);
1664
    if (GetArenaNoVirtual() == NULL) {
1665
      delete temp;
1666
    }
1667
  }
1668
}
1669
void AttrValue::UnsafeArenaSwap(AttrValue* other) {
1670
  if (other == this) return;
1671
  GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1672
  InternalSwap(other);
1673
}
1674
void AttrValue::InternalSwap(AttrValue* other) {
1675
  using std::swap;
1676
  swap(value_, other->value_);
1677
  swap(_oneof_case_[0], other->_oneof_case_[0]);
1678
  _internal_metadata_.Swap(&other->_internal_metadata_);
1679
  swap(_cached_size_, other->_cached_size_);
1680
}
1681

1682
::google::protobuf::Metadata AttrValue::GetMetadata() const {
1683
  protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
1684
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages];
1685
}
1686

1687

1688
// ===================================================================
1689

1690
NameAttrList_AttrEntry_DoNotUse::NameAttrList_AttrEntry_DoNotUse() {}
1691
NameAttrList_AttrEntry_DoNotUse::NameAttrList_AttrEntry_DoNotUse(::google::protobuf::Arena* arena) : SuperType(arena) {}
1692
void NameAttrList_AttrEntry_DoNotUse::MergeFrom(const NameAttrList_AttrEntry_DoNotUse& other) {
1693
  MergeFromInternal(other);
1694
}
1695
::google::protobuf::Metadata NameAttrList_AttrEntry_DoNotUse::GetMetadata() const {
1696
  ::protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
1697
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[2];
1698
}
1699
void NameAttrList_AttrEntry_DoNotUse::MergeFrom(
1700
    const ::google::protobuf::Message& other) {
1701
  ::google::protobuf::Message::MergeFrom(other);
1702
}
1703

1704

1705
// ===================================================================
1706

1707
void NameAttrList::InitAsDefaultInstance() {
1708
}
1709
#if !defined(_MSC_VER) || _MSC_VER >= 1900
1710
const int NameAttrList::kNameFieldNumber;
1711
const int NameAttrList::kAttrFieldNumber;
1712
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
1713

1714
NameAttrList::NameAttrList()
1715
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
1716
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
1717
    ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
1718
  }
1719
  SharedCtor();
1720
  // @@protoc_insertion_point(constructor:opencv_tensorflow.NameAttrList)
1721
}
1722
NameAttrList::NameAttrList(::google::protobuf::Arena* arena)
1723
  : ::google::protobuf::Message(),
1724
  _internal_metadata_(arena),
1725
  attr_(arena) {
1726
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
1727
  SharedCtor();
1728
  RegisterArenaDtor(arena);
1729
  // @@protoc_insertion_point(arena_constructor:opencv_tensorflow.NameAttrList)
1730
}
1731
NameAttrList::NameAttrList(const NameAttrList& from)
1732
  : ::google::protobuf::Message(),
1733
      _internal_metadata_(NULL),
1734
      _cached_size_(0) {
1735
  _internal_metadata_.MergeFrom(from._internal_metadata_);
1736
  attr_.MergeFrom(from.attr_);
1737
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1738
  if (from.name().size() > 0) {
1739
    name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name(),
1740
      GetArenaNoVirtual());
1741
  }
1742
  // @@protoc_insertion_point(copy_constructor:opencv_tensorflow.NameAttrList)
1743
}
1744

1745
void NameAttrList::SharedCtor() {
1746
  name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1747
  _cached_size_ = 0;
1748
}
1749

1750
NameAttrList::~NameAttrList() {
1751
  // @@protoc_insertion_point(destructor:opencv_tensorflow.NameAttrList)
1752
  SharedDtor();
1753
}
1754

1755
void NameAttrList::SharedDtor() {
1756
  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL);
1757
  name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
1758
}
1759

1760
void NameAttrList::ArenaDtor(void* object) {
1761
  NameAttrList* _this = reinterpret_cast< NameAttrList* >(object);
1762
  (void)_this;
1763
}
1764
void NameAttrList::RegisterArenaDtor(::google::protobuf::Arena* arena) {
1765
}
1766
void NameAttrList::SetCachedSize(int size) const {
1767
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1768
  _cached_size_ = size;
1769
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
1770
}
1771
const ::google::protobuf::Descriptor* NameAttrList::descriptor() {
1772
  ::protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
1773
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
1774
}
1775

1776
const NameAttrList& NameAttrList::default_instance() {
1777
  ::protobuf_attr_5fvalue_2eproto::InitDefaultsAttrValue();
1778
  return *internal_default_instance();
1779
}
1780

1781
NameAttrList* NameAttrList::New(::google::protobuf::Arena* arena) const {
1782
  return ::google::protobuf::Arena::CreateMessage<NameAttrList>(arena);
1783
}
1784

1785
void NameAttrList::Clear() {
1786
// @@protoc_insertion_point(message_clear_start:opencv_tensorflow.NameAttrList)
1787
  ::google::protobuf::uint32 cached_has_bits = 0;
1788
  // Prevent compiler warnings about cached_has_bits being unused
1789
  (void) cached_has_bits;
1790

1791
  attr_.Clear();
1792
  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
1793
  _internal_metadata_.Clear();
1794
}
1795

1796
bool NameAttrList::MergePartialFromCodedStream(
1797
    ::google::protobuf::io::CodedInputStream* input) {
1798
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
1799
  ::google::protobuf::uint32 tag;
1800
  // @@protoc_insertion_point(parse_start:opencv_tensorflow.NameAttrList)
1801
  for (;;) {
1802
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
1803
    tag = p.first;
1804
    if (!p.second) goto handle_unusual;
1805
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1806
      // string name = 1;
1807
      case 1: {
1808
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1809
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
1810
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1811
                input, this->mutable_name()));
1812
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1813
            this->name().data(), static_cast<int>(this->name().length()),
1814
            ::google::protobuf::internal::WireFormatLite::PARSE,
1815
            "opencv_tensorflow.NameAttrList.name"));
1816
        } else {
1817
          goto handle_unusual;
1818
        }
1819
        break;
1820
      }
1821

1822
      // map<string, .opencv_tensorflow.AttrValue> attr = 2;
1823
      case 2: {
1824
        if (static_cast< ::google::protobuf::uint8>(tag) ==
1825
            static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) {
1826
          NameAttrList_AttrEntry_DoNotUse::Parser< ::google::protobuf::internal::MapField<
1827
              NameAttrList_AttrEntry_DoNotUse,
1828
              ::std::string, ::opencv_tensorflow::AttrValue,
1829
              ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
1830
              ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
1831
              0 >,
1832
            ::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue > > parser(&attr_);
1833
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1834
              input, &parser));
1835
          DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1836
            parser.key().data(), static_cast<int>(parser.key().length()),
1837
            ::google::protobuf::internal::WireFormatLite::PARSE,
1838
            "opencv_tensorflow.NameAttrList.AttrEntry.key"));
1839
        } else {
1840
          goto handle_unusual;
1841
        }
1842
        break;
1843
      }
1844

1845
      default: {
1846
      handle_unusual:
1847
        if (tag == 0) {
1848
          goto success;
1849
        }
1850
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1851
              input, tag, _internal_metadata_.mutable_unknown_fields()));
1852
        break;
1853
      }
1854
    }
1855
  }
1856
success:
1857
  // @@protoc_insertion_point(parse_success:opencv_tensorflow.NameAttrList)
1858
  return true;
1859
failure:
1860
  // @@protoc_insertion_point(parse_failure:opencv_tensorflow.NameAttrList)
1861
  return false;
1862
#undef DO_
1863
}
1864

1865
void NameAttrList::SerializeWithCachedSizes(
1866
    ::google::protobuf::io::CodedOutputStream* output) const {
1867
  // @@protoc_insertion_point(serialize_start:opencv_tensorflow.NameAttrList)
1868
  ::google::protobuf::uint32 cached_has_bits = 0;
1869
  (void) cached_has_bits;
1870

1871
  // string name = 1;
1872
  if (this->name().size() > 0) {
1873
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1874
      this->name().data(), static_cast<int>(this->name().length()),
1875
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1876
      "opencv_tensorflow.NameAttrList.name");
1877
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
1878
      1, this->name(), output);
1879
  }
1880

1881
  // map<string, .opencv_tensorflow.AttrValue> attr = 2;
1882
  if (!this->attr().empty()) {
1883
    typedef ::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_pointer
1884
        ConstPtr;
1885
    typedef ConstPtr SortItem;
1886
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
1887
    struct Utf8Check {
1888
      static void Check(ConstPtr p) {
1889
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1890
          p->first.data(), static_cast<int>(p->first.length()),
1891
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1892
          "opencv_tensorflow.NameAttrList.AttrEntry.key");
1893
      }
1894
    };
1895

1896
    if (output->IsSerializationDeterministic() &&
1897
        this->attr().size() > 1) {
1898
      ::google::protobuf::scoped_array<SortItem> items(
1899
          new SortItem[this->attr().size()]);
1900
      typedef ::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::size_type size_type;
1901
      size_type n = 0;
1902
      for (::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_iterator
1903
          it = this->attr().begin();
1904
          it != this->attr().end(); ++it, ++n) {
1905
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
1906
      }
1907
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
1908
      ::google::protobuf::scoped_ptr<NameAttrList_AttrEntry_DoNotUse> entry;
1909
      for (size_type i = 0; i < n; i++) {
1910
        entry.reset(attr_.NewEntryWrapper(
1911
            items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second));
1912
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1913
            2, *entry, output);
1914
        if (entry->GetArena() != NULL) {
1915
          entry.release();
1916
        }
1917
        Utf8Check::Check(items[static_cast<ptrdiff_t>(i)]);
1918
      }
1919
    } else {
1920
      ::google::protobuf::scoped_ptr<NameAttrList_AttrEntry_DoNotUse> entry;
1921
      for (::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_iterator
1922
          it = this->attr().begin();
1923
          it != this->attr().end(); ++it) {
1924
        entry.reset(attr_.NewEntryWrapper(
1925
            it->first, it->second));
1926
        ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1927
            2, *entry, output);
1928
        if (entry->GetArena() != NULL) {
1929
          entry.release();
1930
        }
1931
        Utf8Check::Check(&*it);
1932
      }
1933
    }
1934
  }
1935

1936
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
1937
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1938
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), output);
1939
  }
1940
  // @@protoc_insertion_point(serialize_end:opencv_tensorflow.NameAttrList)
1941
}
1942

1943
::google::protobuf::uint8* NameAttrList::InternalSerializeWithCachedSizesToArray(
1944
    bool deterministic, ::google::protobuf::uint8* target) const {
1945
  (void)deterministic; // Unused
1946
  // @@protoc_insertion_point(serialize_to_array_start:opencv_tensorflow.NameAttrList)
1947
  ::google::protobuf::uint32 cached_has_bits = 0;
1948
  (void) cached_has_bits;
1949

1950
  // string name = 1;
1951
  if (this->name().size() > 0) {
1952
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1953
      this->name().data(), static_cast<int>(this->name().length()),
1954
      ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1955
      "opencv_tensorflow.NameAttrList.name");
1956
    target =
1957
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1958
        1, this->name(), target);
1959
  }
1960

1961
  // map<string, .opencv_tensorflow.AttrValue> attr = 2;
1962
  if (!this->attr().empty()) {
1963
    typedef ::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_pointer
1964
        ConstPtr;
1965
    typedef ConstPtr SortItem;
1966
    typedef ::google::protobuf::internal::CompareByDerefFirst<SortItem> Less;
1967
    struct Utf8Check {
1968
      static void Check(ConstPtr p) {
1969
        ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
1970
          p->first.data(), static_cast<int>(p->first.length()),
1971
          ::google::protobuf::internal::WireFormatLite::SERIALIZE,
1972
          "opencv_tensorflow.NameAttrList.AttrEntry.key");
1973
      }
1974
    };
1975

1976
    if (deterministic &&
1977
        this->attr().size() > 1) {
1978
      ::google::protobuf::scoped_array<SortItem> items(
1979
          new SortItem[this->attr().size()]);
1980
      typedef ::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::size_type size_type;
1981
      size_type n = 0;
1982
      for (::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_iterator
1983
          it = this->attr().begin();
1984
          it != this->attr().end(); ++it, ++n) {
1985
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
1986
      }
1987
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
1988
      ::google::protobuf::scoped_ptr<NameAttrList_AttrEntry_DoNotUse> entry;
1989
      for (size_type i = 0; i < n; i++) {
1990
        entry.reset(attr_.NewEntryWrapper(
1991
            items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second));
1992
        target = ::google::protobuf::internal::WireFormatLite::
1993
                   InternalWriteMessageNoVirtualToArray(
1994
                       2, *entry, deterministic, target);
1995
;
1996
        if (entry->GetArena() != NULL) {
1997
          entry.release();
1998
        }
1999
        Utf8Check::Check(items[static_cast<ptrdiff_t>(i)]);
2000
      }
2001
    } else {
2002
      ::google::protobuf::scoped_ptr<NameAttrList_AttrEntry_DoNotUse> entry;
2003
      for (::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_iterator
2004
          it = this->attr().begin();
2005
          it != this->attr().end(); ++it) {
2006
        entry.reset(attr_.NewEntryWrapper(
2007
            it->first, it->second));
2008
        target = ::google::protobuf::internal::WireFormatLite::
2009
                   InternalWriteMessageNoVirtualToArray(
2010
                       2, *entry, deterministic, target);
2011
;
2012
        if (entry->GetArena() != NULL) {
2013
          entry.release();
2014
        }
2015
        Utf8Check::Check(&*it);
2016
      }
2017
    }
2018
  }
2019

2020
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
2021
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2022
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()), target);
2023
  }
2024
  // @@protoc_insertion_point(serialize_to_array_end:opencv_tensorflow.NameAttrList)
2025
  return target;
2026
}
2027

2028
size_t NameAttrList::ByteSizeLong() const {
2029
// @@protoc_insertion_point(message_byte_size_start:opencv_tensorflow.NameAttrList)
2030
  size_t total_size = 0;
2031

2032
  if ((_internal_metadata_.have_unknown_fields() &&  ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) {
2033
    total_size +=
2034
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2035
        (::google::protobuf::internal::GetProto3PreserveUnknownsDefault()   ? _internal_metadata_.unknown_fields()   : _internal_metadata_.default_instance()));
2036
  }
2037
  // map<string, .opencv_tensorflow.AttrValue> attr = 2;
2038
  total_size += 1 *
2039
      ::google::protobuf::internal::FromIntSize(this->attr_size());
2040
  {
2041
    ::google::protobuf::scoped_ptr<NameAttrList_AttrEntry_DoNotUse> entry;
2042
    for (::google::protobuf::Map< ::std::string, ::opencv_tensorflow::AttrValue >::const_iterator
2043
        it = this->attr().begin();
2044
        it != this->attr().end(); ++it) {
2045
      if (entry.get() != NULL && entry->GetArena() != NULL) {
2046
        entry.release();
2047
      }
2048
      entry.reset(attr_.NewEntryWrapper(it->first, it->second));
2049
      total_size += ::google::protobuf::internal::WireFormatLite::
2050
          MessageSizeNoVirtual(*entry);
2051
    }
2052
    if (entry.get() != NULL && entry->GetArena() != NULL) {
2053
      entry.release();
2054
    }
2055
  }
2056

2057
  // string name = 1;
2058
  if (this->name().size() > 0) {
2059
    total_size += 1 +
2060
      ::google::protobuf::internal::WireFormatLite::StringSize(
2061
        this->name());
2062
  }
2063

2064
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
2065
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2066
  _cached_size_ = cached_size;
2067
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
2068
  return total_size;
2069
}
2070

2071
void NameAttrList::MergeFrom(const ::google::protobuf::Message& from) {
2072
// @@protoc_insertion_point(generalized_merge_from_start:opencv_tensorflow.NameAttrList)
2073
  GOOGLE_DCHECK_NE(&from, this);
2074
  const NameAttrList* source =
2075
      ::google::protobuf::internal::DynamicCastToGenerated<const NameAttrList>(
2076
          &from);
2077
  if (source == NULL) {
2078
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:opencv_tensorflow.NameAttrList)
2079
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2080
  } else {
2081
  // @@protoc_insertion_point(generalized_merge_from_cast_success:opencv_tensorflow.NameAttrList)
2082
    MergeFrom(*source);
2083
  }
2084
}
2085

2086
void NameAttrList::MergeFrom(const NameAttrList& from) {
2087
// @@protoc_insertion_point(class_specific_merge_from_start:opencv_tensorflow.NameAttrList)
2088
  GOOGLE_DCHECK_NE(&from, this);
2089
  _internal_metadata_.MergeFrom(from._internal_metadata_);
2090
  ::google::protobuf::uint32 cached_has_bits = 0;
2091
  (void) cached_has_bits;
2092

2093
  attr_.MergeFrom(from.attr_);
2094
  if (from.name().size() > 0) {
2095
    set_name(from.name());
2096
  }
2097
}
2098

2099
void NameAttrList::CopyFrom(const ::google::protobuf::Message& from) {
2100
// @@protoc_insertion_point(generalized_copy_from_start:opencv_tensorflow.NameAttrList)
2101
  if (&from == this) return;
2102
  Clear();
2103
  MergeFrom(from);
2104
}
2105

2106
void NameAttrList::CopyFrom(const NameAttrList& from) {
2107
// @@protoc_insertion_point(class_specific_copy_from_start:opencv_tensorflow.NameAttrList)
2108
  if (&from == this) return;
2109
  Clear();
2110
  MergeFrom(from);
2111
}
2112

2113
bool NameAttrList::IsInitialized() const {
2114
  return true;
2115
}
2116

2117
void NameAttrList::Swap(NameAttrList* other) {
2118
  if (other == this) return;
2119
  if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2120
    InternalSwap(other);
2121
  } else {
2122
    NameAttrList* temp = New(GetArenaNoVirtual());
2123
    temp->MergeFrom(*other);
2124
    other->CopyFrom(*this);
2125
    InternalSwap(temp);
2126
    if (GetArenaNoVirtual() == NULL) {
2127
      delete temp;
2128
    }
2129
  }
2130
}
2131
void NameAttrList::UnsafeArenaSwap(NameAttrList* other) {
2132
  if (other == this) return;
2133
  GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2134
  InternalSwap(other);
2135
}
2136
void NameAttrList::InternalSwap(NameAttrList* other) {
2137
  using std::swap;
2138
  attr_.Swap(&other->attr_);
2139
  name_.Swap(&other->name_);
2140
  _internal_metadata_.Swap(&other->_internal_metadata_);
2141
  swap(_cached_size_, other->_cached_size_);
2142
}
2143

2144
::google::protobuf::Metadata NameAttrList::GetMetadata() const {
2145
  protobuf_attr_5fvalue_2eproto::protobuf_AssignDescriptorsOnce();
2146
  return ::protobuf_attr_5fvalue_2eproto::file_level_metadata[kIndexInFileMessages];
2147
}
2148

2149

2150
// @@protoc_insertion_point(namespace_scope)
2151
}  // namespace opencv_tensorflow
2152

2153
// @@protoc_insertion_point(global_scope)
2154

2155
Product

Resources

Company
