1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/framework/graph_transfer_info.proto
3
4 #include "tensorflow/core/framework/graph_transfer_info.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace tensorflow {
GraphTransferNodeInput(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR GraphTransferNodeInput::GraphTransferNodeInput(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.node_id_)*/0
25 , /*decltype(_impl_.output_port_)*/0
26 , /*decltype(_impl_._cached_size_)*/{}} {}
27 struct GraphTransferNodeInputDefaultTypeInternal {
GraphTransferNodeInputDefaultTypeInternaltensorflow::GraphTransferNodeInputDefaultTypeInternal28 PROTOBUF_CONSTEXPR GraphTransferNodeInputDefaultTypeInternal()
29 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferNodeInputDefaultTypeInternaltensorflow::GraphTransferNodeInputDefaultTypeInternal30 ~GraphTransferNodeInputDefaultTypeInternal() {}
31 union { // NOLINT(misc-non-private-member-variables-in-classes)
32 GraphTransferNodeInput _instance;
33 };
34 };
35 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferNodeInputDefaultTypeInternal _GraphTransferNodeInput_default_instance_;
GraphTransferNodeInfo(::_pbi::ConstantInitialized)36 PROTOBUF_CONSTEXPR GraphTransferNodeInfo::GraphTransferNodeInfo(
37 ::_pbi::ConstantInitialized): _impl_{
38 /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
39 , /*decltype(_impl_.type_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
40 , /*decltype(_impl_.node_id_)*/0
41 , /*decltype(_impl_.soc_op_id_)*/0
42 , /*decltype(_impl_.padding_id_)*/0
43 , /*decltype(_impl_.input_count_)*/0
44 , /*decltype(_impl_.output_count_)*/0
45 , /*decltype(_impl_._cached_size_)*/{}} {}
46 struct GraphTransferNodeInfoDefaultTypeInternal {
GraphTransferNodeInfoDefaultTypeInternaltensorflow::GraphTransferNodeInfoDefaultTypeInternal47 PROTOBUF_CONSTEXPR GraphTransferNodeInfoDefaultTypeInternal()
48 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferNodeInfoDefaultTypeInternaltensorflow::GraphTransferNodeInfoDefaultTypeInternal49 ~GraphTransferNodeInfoDefaultTypeInternal() {}
50 union { // NOLINT(misc-non-private-member-variables-in-classes)
51 GraphTransferNodeInfo _instance;
52 };
53 };
54 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferNodeInfoDefaultTypeInternal _GraphTransferNodeInfo_default_instance_;
GraphTransferConstNodeInfo(::_pbi::ConstantInitialized)55 PROTOBUF_CONSTEXPR GraphTransferConstNodeInfo::GraphTransferConstNodeInfo(
56 ::_pbi::ConstantInitialized): _impl_{
57 /*decltype(_impl_.shape_)*/{}
58 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
59 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
60 , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
61 , /*decltype(_impl_.node_id_)*/0
62 , /*decltype(_impl_.dtype_)*/0
63 , /*decltype(_impl_._cached_size_)*/{}} {}
64 struct GraphTransferConstNodeInfoDefaultTypeInternal {
GraphTransferConstNodeInfoDefaultTypeInternaltensorflow::GraphTransferConstNodeInfoDefaultTypeInternal65 PROTOBUF_CONSTEXPR GraphTransferConstNodeInfoDefaultTypeInternal()
66 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferConstNodeInfoDefaultTypeInternaltensorflow::GraphTransferConstNodeInfoDefaultTypeInternal67 ~GraphTransferConstNodeInfoDefaultTypeInternal() {}
68 union { // NOLINT(misc-non-private-member-variables-in-classes)
69 GraphTransferConstNodeInfo _instance;
70 };
71 };
72 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferConstNodeInfoDefaultTypeInternal _GraphTransferConstNodeInfo_default_instance_;
GraphTransferNodeInputInfo(::_pbi::ConstantInitialized)73 PROTOBUF_CONSTEXPR GraphTransferNodeInputInfo::GraphTransferNodeInputInfo(
74 ::_pbi::ConstantInitialized): _impl_{
75 /*decltype(_impl_.node_input_)*/{}
76 , /*decltype(_impl_.node_id_)*/0
77 , /*decltype(_impl_._cached_size_)*/{}} {}
78 struct GraphTransferNodeInputInfoDefaultTypeInternal {
GraphTransferNodeInputInfoDefaultTypeInternaltensorflow::GraphTransferNodeInputInfoDefaultTypeInternal79 PROTOBUF_CONSTEXPR GraphTransferNodeInputInfoDefaultTypeInternal()
80 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferNodeInputInfoDefaultTypeInternaltensorflow::GraphTransferNodeInputInfoDefaultTypeInternal81 ~GraphTransferNodeInputInfoDefaultTypeInternal() {}
82 union { // NOLINT(misc-non-private-member-variables-in-classes)
83 GraphTransferNodeInputInfo _instance;
84 };
85 };
86 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferNodeInputInfoDefaultTypeInternal _GraphTransferNodeInputInfo_default_instance_;
GraphTransferNodeOutputInfo(::_pbi::ConstantInitialized)87 PROTOBUF_CONSTEXPR GraphTransferNodeOutputInfo::GraphTransferNodeOutputInfo(
88 ::_pbi::ConstantInitialized): _impl_{
89 /*decltype(_impl_.max_byte_size_)*/{}
90 , /*decltype(_impl_._max_byte_size_cached_byte_size_)*/{0}
91 , /*decltype(_impl_.node_id_)*/0
92 , /*decltype(_impl_._cached_size_)*/{}} {}
93 struct GraphTransferNodeOutputInfoDefaultTypeInternal {
GraphTransferNodeOutputInfoDefaultTypeInternaltensorflow::GraphTransferNodeOutputInfoDefaultTypeInternal94 PROTOBUF_CONSTEXPR GraphTransferNodeOutputInfoDefaultTypeInternal()
95 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferNodeOutputInfoDefaultTypeInternaltensorflow::GraphTransferNodeOutputInfoDefaultTypeInternal96 ~GraphTransferNodeOutputInfoDefaultTypeInternal() {}
97 union { // NOLINT(misc-non-private-member-variables-in-classes)
98 GraphTransferNodeOutputInfo _instance;
99 };
100 };
101 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferNodeOutputInfoDefaultTypeInternal _GraphTransferNodeOutputInfo_default_instance_;
GraphTransferGraphInputNodeInfo(::_pbi::ConstantInitialized)102 PROTOBUF_CONSTEXPR GraphTransferGraphInputNodeInfo::GraphTransferGraphInputNodeInfo(
103 ::_pbi::ConstantInitialized): _impl_{
104 /*decltype(_impl_.shape_)*/{}
105 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
106 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
107 , /*decltype(_impl_.dtype_)*/0
108 , /*decltype(_impl_._cached_size_)*/{}} {}
109 struct GraphTransferGraphInputNodeInfoDefaultTypeInternal {
GraphTransferGraphInputNodeInfoDefaultTypeInternaltensorflow::GraphTransferGraphInputNodeInfoDefaultTypeInternal110 PROTOBUF_CONSTEXPR GraphTransferGraphInputNodeInfoDefaultTypeInternal()
111 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferGraphInputNodeInfoDefaultTypeInternaltensorflow::GraphTransferGraphInputNodeInfoDefaultTypeInternal112 ~GraphTransferGraphInputNodeInfoDefaultTypeInternal() {}
113 union { // NOLINT(misc-non-private-member-variables-in-classes)
114 GraphTransferGraphInputNodeInfo _instance;
115 };
116 };
117 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferGraphInputNodeInfoDefaultTypeInternal _GraphTransferGraphInputNodeInfo_default_instance_;
GraphTransferGraphOutputNodeInfo(::_pbi::ConstantInitialized)118 PROTOBUF_CONSTEXPR GraphTransferGraphOutputNodeInfo::GraphTransferGraphOutputNodeInfo(
119 ::_pbi::ConstantInitialized): _impl_{
120 /*decltype(_impl_.shape_)*/{}
121 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
122 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
123 , /*decltype(_impl_.dtype_)*/0
124 , /*decltype(_impl_._cached_size_)*/{}} {}
125 struct GraphTransferGraphOutputNodeInfoDefaultTypeInternal {
GraphTransferGraphOutputNodeInfoDefaultTypeInternaltensorflow::GraphTransferGraphOutputNodeInfoDefaultTypeInternal126 PROTOBUF_CONSTEXPR GraphTransferGraphOutputNodeInfoDefaultTypeInternal()
127 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferGraphOutputNodeInfoDefaultTypeInternaltensorflow::GraphTransferGraphOutputNodeInfoDefaultTypeInternal128 ~GraphTransferGraphOutputNodeInfoDefaultTypeInternal() {}
129 union { // NOLINT(misc-non-private-member-variables-in-classes)
130 GraphTransferGraphOutputNodeInfo _instance;
131 };
132 };
133 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferGraphOutputNodeInfoDefaultTypeInternal _GraphTransferGraphOutputNodeInfo_default_instance_;
GraphTransferInfo(::_pbi::ConstantInitialized)134 PROTOBUF_CONSTEXPR GraphTransferInfo::GraphTransferInfo(
135 ::_pbi::ConstantInitialized): _impl_{
136 /*decltype(_impl_.node_info_)*/{}
137 , /*decltype(_impl_.const_node_info_)*/{}
138 , /*decltype(_impl_.node_input_info_)*/{}
139 , /*decltype(_impl_.node_output_info_)*/{}
140 , /*decltype(_impl_.graph_input_node_info_)*/{}
141 , /*decltype(_impl_.graph_output_node_info_)*/{}
142 , /*decltype(_impl_.destination_)*/0
143 , /*decltype(_impl_._cached_size_)*/{}} {}
144 struct GraphTransferInfoDefaultTypeInternal {
GraphTransferInfoDefaultTypeInternaltensorflow::GraphTransferInfoDefaultTypeInternal145 PROTOBUF_CONSTEXPR GraphTransferInfoDefaultTypeInternal()
146 : _instance(::_pbi::ConstantInitialized{}) {}
~GraphTransferInfoDefaultTypeInternaltensorflow::GraphTransferInfoDefaultTypeInternal147 ~GraphTransferInfoDefaultTypeInternal() {}
148 union { // NOLINT(misc-non-private-member-variables-in-classes)
149 GraphTransferInfo _instance;
150 };
151 };
152 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GraphTransferInfoDefaultTypeInternal _GraphTransferInfo_default_instance_;
153 } // namespace tensorflow
154 namespace tensorflow {
GraphTransferInfo_Destination_IsValid(int value)155 bool GraphTransferInfo_Destination_IsValid(int value) {
156 switch (value) {
157 case 0:
158 case 1:
159 return true;
160 default:
161 return false;
162 }
163 }
164
165 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> GraphTransferInfo_Destination_strings[2] = {};
166
167 static const char GraphTransferInfo_Destination_names[] =
168 "HEXAGON"
169 "NOP";
170
171 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GraphTransferInfo_Destination_entries[] = {
172 { {GraphTransferInfo_Destination_names + 0, 7}, 1 },
173 { {GraphTransferInfo_Destination_names + 7, 3}, 0 },
174 };
175
176 static const int GraphTransferInfo_Destination_entries_by_number[] = {
177 1, // 0 -> NOP
178 0, // 1 -> HEXAGON
179 };
180
GraphTransferInfo_Destination_Name(GraphTransferInfo_Destination value)181 const std::string& GraphTransferInfo_Destination_Name(
182 GraphTransferInfo_Destination value) {
183 static const bool dummy =
184 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
185 GraphTransferInfo_Destination_entries,
186 GraphTransferInfo_Destination_entries_by_number,
187 2, GraphTransferInfo_Destination_strings);
188 (void) dummy;
189 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
190 GraphTransferInfo_Destination_entries,
191 GraphTransferInfo_Destination_entries_by_number,
192 2, value);
193 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
194 GraphTransferInfo_Destination_strings[idx].get();
195 }
GraphTransferInfo_Destination_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,GraphTransferInfo_Destination * value)196 bool GraphTransferInfo_Destination_Parse(
197 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, GraphTransferInfo_Destination* value) {
198 int int_value;
199 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
200 GraphTransferInfo_Destination_entries, 2, name, &int_value);
201 if (success) {
202 *value = static_cast<GraphTransferInfo_Destination>(int_value);
203 }
204 return success;
205 }
206 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
207 constexpr GraphTransferInfo_Destination GraphTransferInfo::NOP;
208 constexpr GraphTransferInfo_Destination GraphTransferInfo::HEXAGON;
209 constexpr GraphTransferInfo_Destination GraphTransferInfo::Destination_MIN;
210 constexpr GraphTransferInfo_Destination GraphTransferInfo::Destination_MAX;
211 constexpr int GraphTransferInfo::Destination_ARRAYSIZE;
212 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
213
214 // ===================================================================
215
216 class GraphTransferNodeInput::_Internal {
217 public:
218 };
219
GraphTransferNodeInput(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)220 GraphTransferNodeInput::GraphTransferNodeInput(::PROTOBUF_NAMESPACE_ID::Arena* arena,
221 bool is_message_owned)
222 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
223 SharedCtor(arena, is_message_owned);
224 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferNodeInput)
225 }
GraphTransferNodeInput(const GraphTransferNodeInput & from)226 GraphTransferNodeInput::GraphTransferNodeInput(const GraphTransferNodeInput& from)
227 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
228 GraphTransferNodeInput* const _this = this; (void)_this;
229 new (&_impl_) Impl_{
230 decltype(_impl_.node_id_){}
231 , decltype(_impl_.output_port_){}
232 , /*decltype(_impl_._cached_size_)*/{}};
233
234 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
235 ::memcpy(&_impl_.node_id_, &from._impl_.node_id_,
236 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.output_port_) -
237 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.output_port_));
238 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferNodeInput)
239 }
240
SharedCtor(::_pb::Arena * arena,bool is_message_owned)241 inline void GraphTransferNodeInput::SharedCtor(
242 ::_pb::Arena* arena, bool is_message_owned) {
243 (void)arena;
244 (void)is_message_owned;
245 new (&_impl_) Impl_{
246 decltype(_impl_.node_id_){0}
247 , decltype(_impl_.output_port_){0}
248 , /*decltype(_impl_._cached_size_)*/{}
249 };
250 }
251
~GraphTransferNodeInput()252 GraphTransferNodeInput::~GraphTransferNodeInput() {
253 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferNodeInput)
254 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
255 (void)arena;
256 return;
257 }
258 SharedDtor();
259 }
260
SharedDtor()261 inline void GraphTransferNodeInput::SharedDtor() {
262 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
263 }
264
SetCachedSize(int size) const265 void GraphTransferNodeInput::SetCachedSize(int size) const {
266 _impl_._cached_size_.Set(size);
267 }
268
Clear()269 void GraphTransferNodeInput::Clear() {
270 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferNodeInput)
271 ::uint32_t cached_has_bits = 0;
272 // Prevent compiler warnings about cached_has_bits being unused
273 (void) cached_has_bits;
274
275 ::memset(&_impl_.node_id_, 0, static_cast<size_t>(
276 reinterpret_cast<char*>(&_impl_.output_port_) -
277 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.output_port_));
278 _internal_metadata_.Clear<std::string>();
279 }
280
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)281 const char* GraphTransferNodeInput::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
282 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
283 while (!ctx->Done(&ptr)) {
284 ::uint32_t tag;
285 ptr = ::_pbi::ReadTag(ptr, &tag);
286 switch (tag >> 3) {
287 // int32 node_id = 1;
288 case 1:
289 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
290 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
291 CHK_(ptr);
292 } else {
293 goto handle_unusual;
294 }
295 continue;
296 // int32 output_port = 2;
297 case 2:
298 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
299 _impl_.output_port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
300 CHK_(ptr);
301 } else {
302 goto handle_unusual;
303 }
304 continue;
305 default:
306 goto handle_unusual;
307 } // switch
308 handle_unusual:
309 if ((tag == 0) || ((tag & 7) == 4)) {
310 CHK_(ptr);
311 ctx->SetLastTag(tag);
312 goto message_done;
313 }
314 ptr = UnknownFieldParse(
315 tag,
316 _internal_metadata_.mutable_unknown_fields<std::string>(),
317 ptr, ctx);
318 CHK_(ptr != nullptr);
319 } // while
320 message_done:
321 return ptr;
322 failure:
323 ptr = nullptr;
324 goto message_done;
325 #undef CHK_
326 }
327
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const328 ::uint8_t* GraphTransferNodeInput::_InternalSerialize(
329 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
330 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferNodeInput)
331 ::uint32_t cached_has_bits = 0;
332 (void) cached_has_bits;
333
334 // int32 node_id = 1;
335 if (this->_internal_node_id() != 0) {
336 target = stream->EnsureSpace(target);
337 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_node_id(), target);
338 }
339
340 // int32 output_port = 2;
341 if (this->_internal_output_port() != 0) {
342 target = stream->EnsureSpace(target);
343 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_output_port(), target);
344 }
345
346 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
347 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
348 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
349 }
350 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferNodeInput)
351 return target;
352 }
353
ByteSizeLong() const354 size_t GraphTransferNodeInput::ByteSizeLong() const {
355 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferNodeInput)
356 size_t total_size = 0;
357
358 ::uint32_t cached_has_bits = 0;
359 // Prevent compiler warnings about cached_has_bits being unused
360 (void) cached_has_bits;
361
362 // int32 node_id = 1;
363 if (this->_internal_node_id() != 0) {
364 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
365 }
366
367 // int32 output_port = 2;
368 if (this->_internal_output_port() != 0) {
369 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_output_port());
370 }
371
372 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
373 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
374 }
375 int cached_size = ::_pbi::ToCachedSize(total_size);
376 SetCachedSize(cached_size);
377 return total_size;
378 }
379
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)380 void GraphTransferNodeInput::CheckTypeAndMergeFrom(
381 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
382 MergeFrom(*::_pbi::DownCast<const GraphTransferNodeInput*>(
383 &from));
384 }
385
MergeFrom(const GraphTransferNodeInput & from)386 void GraphTransferNodeInput::MergeFrom(const GraphTransferNodeInput& from) {
387 GraphTransferNodeInput* const _this = this;
388 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferNodeInput)
389 GOOGLE_DCHECK_NE(&from, _this);
390 ::uint32_t cached_has_bits = 0;
391 (void) cached_has_bits;
392
393 if (from._internal_node_id() != 0) {
394 _this->_internal_set_node_id(from._internal_node_id());
395 }
396 if (from._internal_output_port() != 0) {
397 _this->_internal_set_output_port(from._internal_output_port());
398 }
399 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
400 }
401
CopyFrom(const GraphTransferNodeInput & from)402 void GraphTransferNodeInput::CopyFrom(const GraphTransferNodeInput& from) {
403 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferNodeInput)
404 if (&from == this) return;
405 Clear();
406 MergeFrom(from);
407 }
408
IsInitialized() const409 bool GraphTransferNodeInput::IsInitialized() const {
410 return true;
411 }
412
InternalSwap(GraphTransferNodeInput * other)413 void GraphTransferNodeInput::InternalSwap(GraphTransferNodeInput* other) {
414 using std::swap;
415 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
416 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
417 PROTOBUF_FIELD_OFFSET(GraphTransferNodeInput, _impl_.output_port_)
418 + sizeof(GraphTransferNodeInput::_impl_.output_port_) // NOLINT
419 - PROTOBUF_FIELD_OFFSET(GraphTransferNodeInput, _impl_.node_id_)>(
420 reinterpret_cast<char*>(&_impl_.node_id_),
421 reinterpret_cast<char*>(&other->_impl_.node_id_));
422 }
423
GetTypeName() const424 std::string GraphTransferNodeInput::GetTypeName() const {
425 return "tensorflow.GraphTransferNodeInput";
426 }
427
428
429 // ===================================================================
430
431 class GraphTransferNodeInfo::_Internal {
432 public:
433 };
434
GraphTransferNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)435 GraphTransferNodeInfo::GraphTransferNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
436 bool is_message_owned)
437 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
438 SharedCtor(arena, is_message_owned);
439 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferNodeInfo)
440 }
GraphTransferNodeInfo(const GraphTransferNodeInfo & from)441 GraphTransferNodeInfo::GraphTransferNodeInfo(const GraphTransferNodeInfo& from)
442 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
443 GraphTransferNodeInfo* const _this = this; (void)_this;
444 new (&_impl_) Impl_{
445 decltype(_impl_.name_){}
446 , decltype(_impl_.type_name_){}
447 , decltype(_impl_.node_id_){}
448 , decltype(_impl_.soc_op_id_){}
449 , decltype(_impl_.padding_id_){}
450 , decltype(_impl_.input_count_){}
451 , decltype(_impl_.output_count_){}
452 , /*decltype(_impl_._cached_size_)*/{}};
453
454 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
455 _impl_.name_.InitDefault();
456 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
457 _impl_.name_.Set("", GetArenaForAllocation());
458 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
459 if (!from._internal_name().empty()) {
460 _this->_impl_.name_.Set(from._internal_name(),
461 _this->GetArenaForAllocation());
462 }
463 _impl_.type_name_.InitDefault();
464 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
465 _impl_.type_name_.Set("", GetArenaForAllocation());
466 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
467 if (!from._internal_type_name().empty()) {
468 _this->_impl_.type_name_.Set(from._internal_type_name(),
469 _this->GetArenaForAllocation());
470 }
471 ::memcpy(&_impl_.node_id_, &from._impl_.node_id_,
472 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.output_count_) -
473 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.output_count_));
474 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferNodeInfo)
475 }
476
SharedCtor(::_pb::Arena * arena,bool is_message_owned)477 inline void GraphTransferNodeInfo::SharedCtor(
478 ::_pb::Arena* arena, bool is_message_owned) {
479 (void)arena;
480 (void)is_message_owned;
481 new (&_impl_) Impl_{
482 decltype(_impl_.name_){}
483 , decltype(_impl_.type_name_){}
484 , decltype(_impl_.node_id_){0}
485 , decltype(_impl_.soc_op_id_){0}
486 , decltype(_impl_.padding_id_){0}
487 , decltype(_impl_.input_count_){0}
488 , decltype(_impl_.output_count_){0}
489 , /*decltype(_impl_._cached_size_)*/{}
490 };
491 _impl_.name_.InitDefault();
492 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
493 _impl_.name_.Set("", GetArenaForAllocation());
494 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
495 _impl_.type_name_.InitDefault();
496 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
497 _impl_.type_name_.Set("", GetArenaForAllocation());
498 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
499 }
500
~GraphTransferNodeInfo()501 GraphTransferNodeInfo::~GraphTransferNodeInfo() {
502 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferNodeInfo)
503 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
504 (void)arena;
505 return;
506 }
507 SharedDtor();
508 }
509
SharedDtor()510 inline void GraphTransferNodeInfo::SharedDtor() {
511 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
512 _impl_.name_.Destroy();
513 _impl_.type_name_.Destroy();
514 }
515
SetCachedSize(int size) const516 void GraphTransferNodeInfo::SetCachedSize(int size) const {
517 _impl_._cached_size_.Set(size);
518 }
519
Clear()520 void GraphTransferNodeInfo::Clear() {
521 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferNodeInfo)
522 ::uint32_t cached_has_bits = 0;
523 // Prevent compiler warnings about cached_has_bits being unused
524 (void) cached_has_bits;
525
526 _impl_.name_.ClearToEmpty();
527 _impl_.type_name_.ClearToEmpty();
528 ::memset(&_impl_.node_id_, 0, static_cast<size_t>(
529 reinterpret_cast<char*>(&_impl_.output_count_) -
530 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.output_count_));
531 _internal_metadata_.Clear<std::string>();
532 }
533
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)534 const char* GraphTransferNodeInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
535 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
536 while (!ctx->Done(&ptr)) {
537 ::uint32_t tag;
538 ptr = ::_pbi::ReadTag(ptr, &tag);
539 switch (tag >> 3) {
540 // string name = 1;
541 case 1:
542 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
543 auto str = _internal_mutable_name();
544 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
545 CHK_(ptr);
546 CHK_(::_pbi::VerifyUTF8(str, nullptr));
547 } else {
548 goto handle_unusual;
549 }
550 continue;
551 // int32 node_id = 2;
552 case 2:
553 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
554 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
555 CHK_(ptr);
556 } else {
557 goto handle_unusual;
558 }
559 continue;
560 // string type_name = 3;
561 case 3:
562 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
563 auto str = _internal_mutable_type_name();
564 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
565 CHK_(ptr);
566 CHK_(::_pbi::VerifyUTF8(str, nullptr));
567 } else {
568 goto handle_unusual;
569 }
570 continue;
571 // int32 soc_op_id = 4;
572 case 4:
573 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
574 _impl_.soc_op_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
575 CHK_(ptr);
576 } else {
577 goto handle_unusual;
578 }
579 continue;
580 // int32 padding_id = 5;
581 case 5:
582 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
583 _impl_.padding_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
584 CHK_(ptr);
585 } else {
586 goto handle_unusual;
587 }
588 continue;
589 // int32 input_count = 6;
590 case 6:
591 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
592 _impl_.input_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
593 CHK_(ptr);
594 } else {
595 goto handle_unusual;
596 }
597 continue;
598 // int32 output_count = 7;
599 case 7:
600 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
601 _impl_.output_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
602 CHK_(ptr);
603 } else {
604 goto handle_unusual;
605 }
606 continue;
607 default:
608 goto handle_unusual;
609 } // switch
610 handle_unusual:
611 if ((tag == 0) || ((tag & 7) == 4)) {
612 CHK_(ptr);
613 ctx->SetLastTag(tag);
614 goto message_done;
615 }
616 ptr = UnknownFieldParse(
617 tag,
618 _internal_metadata_.mutable_unknown_fields<std::string>(),
619 ptr, ctx);
620 CHK_(ptr != nullptr);
621 } // while
622 message_done:
623 return ptr;
624 failure:
625 ptr = nullptr;
626 goto message_done;
627 #undef CHK_
628 }
629
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const630 ::uint8_t* GraphTransferNodeInfo::_InternalSerialize(
631 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
632 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferNodeInfo)
633 ::uint32_t cached_has_bits = 0;
634 (void) cached_has_bits;
635
636 // string name = 1;
637 if (!this->_internal_name().empty()) {
638 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
639 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
640 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
641 "tensorflow.GraphTransferNodeInfo.name");
642 target = stream->WriteStringMaybeAliased(
643 1, this->_internal_name(), target);
644 }
645
646 // int32 node_id = 2;
647 if (this->_internal_node_id() != 0) {
648 target = stream->EnsureSpace(target);
649 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_node_id(), target);
650 }
651
652 // string type_name = 3;
653 if (!this->_internal_type_name().empty()) {
654 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
655 this->_internal_type_name().data(), static_cast<int>(this->_internal_type_name().length()),
656 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
657 "tensorflow.GraphTransferNodeInfo.type_name");
658 target = stream->WriteStringMaybeAliased(
659 3, this->_internal_type_name(), target);
660 }
661
662 // int32 soc_op_id = 4;
663 if (this->_internal_soc_op_id() != 0) {
664 target = stream->EnsureSpace(target);
665 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_soc_op_id(), target);
666 }
667
668 // int32 padding_id = 5;
669 if (this->_internal_padding_id() != 0) {
670 target = stream->EnsureSpace(target);
671 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_padding_id(), target);
672 }
673
674 // int32 input_count = 6;
675 if (this->_internal_input_count() != 0) {
676 target = stream->EnsureSpace(target);
677 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_input_count(), target);
678 }
679
680 // int32 output_count = 7;
681 if (this->_internal_output_count() != 0) {
682 target = stream->EnsureSpace(target);
683 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_output_count(), target);
684 }
685
686 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
687 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
688 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
689 }
690 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferNodeInfo)
691 return target;
692 }
693
ByteSizeLong() const694 size_t GraphTransferNodeInfo::ByteSizeLong() const {
695 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferNodeInfo)
696 size_t total_size = 0;
697
698 ::uint32_t cached_has_bits = 0;
699 // Prevent compiler warnings about cached_has_bits being unused
700 (void) cached_has_bits;
701
702 // string name = 1;
703 if (!this->_internal_name().empty()) {
704 total_size += 1 +
705 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
706 this->_internal_name());
707 }
708
709 // string type_name = 3;
710 if (!this->_internal_type_name().empty()) {
711 total_size += 1 +
712 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
713 this->_internal_type_name());
714 }
715
716 // int32 node_id = 2;
717 if (this->_internal_node_id() != 0) {
718 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
719 }
720
721 // int32 soc_op_id = 4;
722 if (this->_internal_soc_op_id() != 0) {
723 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_soc_op_id());
724 }
725
726 // int32 padding_id = 5;
727 if (this->_internal_padding_id() != 0) {
728 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_padding_id());
729 }
730
731 // int32 input_count = 6;
732 if (this->_internal_input_count() != 0) {
733 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_input_count());
734 }
735
736 // int32 output_count = 7;
737 if (this->_internal_output_count() != 0) {
738 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_output_count());
739 }
740
741 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
742 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
743 }
744 int cached_size = ::_pbi::ToCachedSize(total_size);
745 SetCachedSize(cached_size);
746 return total_size;
747 }
748
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)749 void GraphTransferNodeInfo::CheckTypeAndMergeFrom(
750 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
751 MergeFrom(*::_pbi::DownCast<const GraphTransferNodeInfo*>(
752 &from));
753 }
754
MergeFrom(const GraphTransferNodeInfo & from)755 void GraphTransferNodeInfo::MergeFrom(const GraphTransferNodeInfo& from) {
756 GraphTransferNodeInfo* const _this = this;
757 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferNodeInfo)
758 GOOGLE_DCHECK_NE(&from, _this);
759 ::uint32_t cached_has_bits = 0;
760 (void) cached_has_bits;
761
762 if (!from._internal_name().empty()) {
763 _this->_internal_set_name(from._internal_name());
764 }
765 if (!from._internal_type_name().empty()) {
766 _this->_internal_set_type_name(from._internal_type_name());
767 }
768 if (from._internal_node_id() != 0) {
769 _this->_internal_set_node_id(from._internal_node_id());
770 }
771 if (from._internal_soc_op_id() != 0) {
772 _this->_internal_set_soc_op_id(from._internal_soc_op_id());
773 }
774 if (from._internal_padding_id() != 0) {
775 _this->_internal_set_padding_id(from._internal_padding_id());
776 }
777 if (from._internal_input_count() != 0) {
778 _this->_internal_set_input_count(from._internal_input_count());
779 }
780 if (from._internal_output_count() != 0) {
781 _this->_internal_set_output_count(from._internal_output_count());
782 }
783 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
784 }
785
CopyFrom(const GraphTransferNodeInfo & from)786 void GraphTransferNodeInfo::CopyFrom(const GraphTransferNodeInfo& from) {
787 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferNodeInfo)
788 if (&from == this) return;
789 Clear();
790 MergeFrom(from);
791 }
792
IsInitialized() const793 bool GraphTransferNodeInfo::IsInitialized() const {
794 return true;
795 }
796
InternalSwap(GraphTransferNodeInfo * other)797 void GraphTransferNodeInfo::InternalSwap(GraphTransferNodeInfo* other) {
798 using std::swap;
799 auto* lhs_arena = GetArenaForAllocation();
800 auto* rhs_arena = other->GetArenaForAllocation();
801 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
802 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
803 &_impl_.name_, lhs_arena,
804 &other->_impl_.name_, rhs_arena
805 );
806 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
807 &_impl_.type_name_, lhs_arena,
808 &other->_impl_.type_name_, rhs_arena
809 );
810 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
811 PROTOBUF_FIELD_OFFSET(GraphTransferNodeInfo, _impl_.output_count_)
812 + sizeof(GraphTransferNodeInfo::_impl_.output_count_) // NOLINT
813 - PROTOBUF_FIELD_OFFSET(GraphTransferNodeInfo, _impl_.node_id_)>(
814 reinterpret_cast<char*>(&_impl_.node_id_),
815 reinterpret_cast<char*>(&other->_impl_.node_id_));
816 }
817
GetTypeName() const818 std::string GraphTransferNodeInfo::GetTypeName() const {
819 return "tensorflow.GraphTransferNodeInfo";
820 }
821
822
823 // ===================================================================
824
825 class GraphTransferConstNodeInfo::_Internal {
826 public:
827 };
828
GraphTransferConstNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)829 GraphTransferConstNodeInfo::GraphTransferConstNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
830 bool is_message_owned)
831 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
832 SharedCtor(arena, is_message_owned);
833 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferConstNodeInfo)
834 }
GraphTransferConstNodeInfo(const GraphTransferConstNodeInfo & from)835 GraphTransferConstNodeInfo::GraphTransferConstNodeInfo(const GraphTransferConstNodeInfo& from)
836 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
837 GraphTransferConstNodeInfo* const _this = this; (void)_this;
838 new (&_impl_) Impl_{
839 decltype(_impl_.shape_){from._impl_.shape_}
840 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
841 , decltype(_impl_.name_){}
842 , decltype(_impl_.data_){}
843 , decltype(_impl_.node_id_){}
844 , decltype(_impl_.dtype_){}
845 , /*decltype(_impl_._cached_size_)*/{}};
846
847 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
848 _impl_.name_.InitDefault();
849 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
850 _impl_.name_.Set("", GetArenaForAllocation());
851 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
852 if (!from._internal_name().empty()) {
853 _this->_impl_.name_.Set(from._internal_name(),
854 _this->GetArenaForAllocation());
855 }
856 _impl_.data_.InitDefault();
857 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
858 _impl_.data_.Set("", GetArenaForAllocation());
859 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
860 if (!from._internal_data().empty()) {
861 _this->_impl_.data_.Set(from._internal_data(),
862 _this->GetArenaForAllocation());
863 }
864 ::memcpy(&_impl_.node_id_, &from._impl_.node_id_,
865 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dtype_) -
866 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.dtype_));
867 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferConstNodeInfo)
868 }
869
SharedCtor(::_pb::Arena * arena,bool is_message_owned)870 inline void GraphTransferConstNodeInfo::SharedCtor(
871 ::_pb::Arena* arena, bool is_message_owned) {
872 (void)arena;
873 (void)is_message_owned;
874 new (&_impl_) Impl_{
875 decltype(_impl_.shape_){arena}
876 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
877 , decltype(_impl_.name_){}
878 , decltype(_impl_.data_){}
879 , decltype(_impl_.node_id_){0}
880 , decltype(_impl_.dtype_){0}
881 , /*decltype(_impl_._cached_size_)*/{}
882 };
883 _impl_.name_.InitDefault();
884 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
885 _impl_.name_.Set("", GetArenaForAllocation());
886 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
887 _impl_.data_.InitDefault();
888 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
889 _impl_.data_.Set("", GetArenaForAllocation());
890 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
891 }
892
~GraphTransferConstNodeInfo()893 GraphTransferConstNodeInfo::~GraphTransferConstNodeInfo() {
894 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferConstNodeInfo)
895 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
896 (void)arena;
897 return;
898 }
899 SharedDtor();
900 }
901
SharedDtor()902 inline void GraphTransferConstNodeInfo::SharedDtor() {
903 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
904 _impl_.shape_.~RepeatedField();
905 _impl_.name_.Destroy();
906 _impl_.data_.Destroy();
907 }
908
SetCachedSize(int size) const909 void GraphTransferConstNodeInfo::SetCachedSize(int size) const {
910 _impl_._cached_size_.Set(size);
911 }
912
Clear()913 void GraphTransferConstNodeInfo::Clear() {
914 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferConstNodeInfo)
915 ::uint32_t cached_has_bits = 0;
916 // Prevent compiler warnings about cached_has_bits being unused
917 (void) cached_has_bits;
918
919 _impl_.shape_.Clear();
920 _impl_.name_.ClearToEmpty();
921 _impl_.data_.ClearToEmpty();
922 ::memset(&_impl_.node_id_, 0, static_cast<size_t>(
923 reinterpret_cast<char*>(&_impl_.dtype_) -
924 reinterpret_cast<char*>(&_impl_.node_id_)) + sizeof(_impl_.dtype_));
925 _internal_metadata_.Clear<std::string>();
926 }
927
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)928 const char* GraphTransferConstNodeInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
929 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
930 while (!ctx->Done(&ptr)) {
931 ::uint32_t tag;
932 ptr = ::_pbi::ReadTag(ptr, &tag);
933 switch (tag >> 3) {
934 // string name = 1;
935 case 1:
936 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
937 auto str = _internal_mutable_name();
938 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
939 CHK_(ptr);
940 CHK_(::_pbi::VerifyUTF8(str, nullptr));
941 } else {
942 goto handle_unusual;
943 }
944 continue;
945 // int32 node_id = 2;
946 case 2:
947 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
948 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
949 CHK_(ptr);
950 } else {
951 goto handle_unusual;
952 }
953 continue;
954 // repeated int64 shape = 3;
955 case 3:
956 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
957 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_shape(), ptr, ctx);
958 CHK_(ptr);
959 } else if (static_cast<::uint8_t>(tag) == 24) {
960 _internal_add_shape(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
961 CHK_(ptr);
962 } else {
963 goto handle_unusual;
964 }
965 continue;
966 // bytes data = 4;
967 case 4:
968 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
969 auto str = _internal_mutable_data();
970 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
971 CHK_(ptr);
972 } else {
973 goto handle_unusual;
974 }
975 continue;
976 // .tensorflow.DataType dtype = 5;
977 case 5:
978 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
979 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
980 CHK_(ptr);
981 _internal_set_dtype(static_cast<::tensorflow::DataType>(val));
982 } else {
983 goto handle_unusual;
984 }
985 continue;
986 default:
987 goto handle_unusual;
988 } // switch
989 handle_unusual:
990 if ((tag == 0) || ((tag & 7) == 4)) {
991 CHK_(ptr);
992 ctx->SetLastTag(tag);
993 goto message_done;
994 }
995 ptr = UnknownFieldParse(
996 tag,
997 _internal_metadata_.mutable_unknown_fields<std::string>(),
998 ptr, ctx);
999 CHK_(ptr != nullptr);
1000 } // while
1001 message_done:
1002 return ptr;
1003 failure:
1004 ptr = nullptr;
1005 goto message_done;
1006 #undef CHK_
1007 }
1008
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1009 ::uint8_t* GraphTransferConstNodeInfo::_InternalSerialize(
1010 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1011 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferConstNodeInfo)
1012 ::uint32_t cached_has_bits = 0;
1013 (void) cached_has_bits;
1014
1015 // string name = 1;
1016 if (!this->_internal_name().empty()) {
1017 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1018 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
1019 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1020 "tensorflow.GraphTransferConstNodeInfo.name");
1021 target = stream->WriteStringMaybeAliased(
1022 1, this->_internal_name(), target);
1023 }
1024
1025 // int32 node_id = 2;
1026 if (this->_internal_node_id() != 0) {
1027 target = stream->EnsureSpace(target);
1028 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_node_id(), target);
1029 }
1030
1031 // repeated int64 shape = 3;
1032 {
1033 int byte_size = _impl_._shape_cached_byte_size_.load(std::memory_order_relaxed);
1034 if (byte_size > 0) {
1035 target = stream->WriteInt64Packed(
1036 3, _internal_shape(), byte_size, target);
1037 }
1038 }
1039
1040 // bytes data = 4;
1041 if (!this->_internal_data().empty()) {
1042 target = stream->WriteBytesMaybeAliased(
1043 4, this->_internal_data(), target);
1044 }
1045
1046 // .tensorflow.DataType dtype = 5;
1047 if (this->_internal_dtype() != 0) {
1048 target = stream->EnsureSpace(target);
1049 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1050 5, this->_internal_dtype(), target);
1051 }
1052
1053 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1054 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1055 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1056 }
1057 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferConstNodeInfo)
1058 return target;
1059 }
1060
ByteSizeLong() const1061 size_t GraphTransferConstNodeInfo::ByteSizeLong() const {
1062 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferConstNodeInfo)
1063 size_t total_size = 0;
1064
1065 ::uint32_t cached_has_bits = 0;
1066 // Prevent compiler warnings about cached_has_bits being unused
1067 (void) cached_has_bits;
1068
1069 // repeated int64 shape = 3;
1070 {
1071 size_t data_size = ::_pbi::WireFormatLite::
1072 Int64Size(this->_impl_.shape_);
1073 if (data_size > 0) {
1074 total_size += 1 +
1075 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
1076 }
1077 int cached_size = ::_pbi::ToCachedSize(data_size);
1078 _impl_._shape_cached_byte_size_.store(cached_size,
1079 std::memory_order_relaxed);
1080 total_size += data_size;
1081 }
1082
1083 // string name = 1;
1084 if (!this->_internal_name().empty()) {
1085 total_size += 1 +
1086 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1087 this->_internal_name());
1088 }
1089
1090 // bytes data = 4;
1091 if (!this->_internal_data().empty()) {
1092 total_size += 1 +
1093 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1094 this->_internal_data());
1095 }
1096
1097 // int32 node_id = 2;
1098 if (this->_internal_node_id() != 0) {
1099 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
1100 }
1101
1102 // .tensorflow.DataType dtype = 5;
1103 if (this->_internal_dtype() != 0) {
1104 total_size += 1 +
1105 ::_pbi::WireFormatLite::EnumSize(this->_internal_dtype());
1106 }
1107
1108 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1109 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1110 }
1111 int cached_size = ::_pbi::ToCachedSize(total_size);
1112 SetCachedSize(cached_size);
1113 return total_size;
1114 }
1115
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1116 void GraphTransferConstNodeInfo::CheckTypeAndMergeFrom(
1117 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1118 MergeFrom(*::_pbi::DownCast<const GraphTransferConstNodeInfo*>(
1119 &from));
1120 }
1121
MergeFrom(const GraphTransferConstNodeInfo & from)1122 void GraphTransferConstNodeInfo::MergeFrom(const GraphTransferConstNodeInfo& from) {
1123 GraphTransferConstNodeInfo* const _this = this;
1124 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferConstNodeInfo)
1125 GOOGLE_DCHECK_NE(&from, _this);
1126 ::uint32_t cached_has_bits = 0;
1127 (void) cached_has_bits;
1128
1129 _this->_impl_.shape_.MergeFrom(from._impl_.shape_);
1130 if (!from._internal_name().empty()) {
1131 _this->_internal_set_name(from._internal_name());
1132 }
1133 if (!from._internal_data().empty()) {
1134 _this->_internal_set_data(from._internal_data());
1135 }
1136 if (from._internal_node_id() != 0) {
1137 _this->_internal_set_node_id(from._internal_node_id());
1138 }
1139 if (from._internal_dtype() != 0) {
1140 _this->_internal_set_dtype(from._internal_dtype());
1141 }
1142 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1143 }
1144
CopyFrom(const GraphTransferConstNodeInfo & from)1145 void GraphTransferConstNodeInfo::CopyFrom(const GraphTransferConstNodeInfo& from) {
1146 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferConstNodeInfo)
1147 if (&from == this) return;
1148 Clear();
1149 MergeFrom(from);
1150 }
1151
IsInitialized() const1152 bool GraphTransferConstNodeInfo::IsInitialized() const {
1153 return true;
1154 }
1155
InternalSwap(GraphTransferConstNodeInfo * other)1156 void GraphTransferConstNodeInfo::InternalSwap(GraphTransferConstNodeInfo* other) {
1157 using std::swap;
1158 auto* lhs_arena = GetArenaForAllocation();
1159 auto* rhs_arena = other->GetArenaForAllocation();
1160 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1161 _impl_.shape_.InternalSwap(&other->_impl_.shape_);
1162 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1163 &_impl_.name_, lhs_arena,
1164 &other->_impl_.name_, rhs_arena
1165 );
1166 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1167 &_impl_.data_, lhs_arena,
1168 &other->_impl_.data_, rhs_arena
1169 );
1170 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1171 PROTOBUF_FIELD_OFFSET(GraphTransferConstNodeInfo, _impl_.dtype_)
1172 + sizeof(GraphTransferConstNodeInfo::_impl_.dtype_) // NOLINT
1173 - PROTOBUF_FIELD_OFFSET(GraphTransferConstNodeInfo, _impl_.node_id_)>(
1174 reinterpret_cast<char*>(&_impl_.node_id_),
1175 reinterpret_cast<char*>(&other->_impl_.node_id_));
1176 }
1177
GetTypeName() const1178 std::string GraphTransferConstNodeInfo::GetTypeName() const {
1179 return "tensorflow.GraphTransferConstNodeInfo";
1180 }
1181
1182
1183 // ===================================================================
1184
1185 class GraphTransferNodeInputInfo::_Internal {
1186 public:
1187 };
1188
GraphTransferNodeInputInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1189 GraphTransferNodeInputInfo::GraphTransferNodeInputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1190 bool is_message_owned)
1191 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1192 SharedCtor(arena, is_message_owned);
1193 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferNodeInputInfo)
1194 }
GraphTransferNodeInputInfo(const GraphTransferNodeInputInfo & from)1195 GraphTransferNodeInputInfo::GraphTransferNodeInputInfo(const GraphTransferNodeInputInfo& from)
1196 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1197 GraphTransferNodeInputInfo* const _this = this; (void)_this;
1198 new (&_impl_) Impl_{
1199 decltype(_impl_.node_input_){from._impl_.node_input_}
1200 , decltype(_impl_.node_id_){}
1201 , /*decltype(_impl_._cached_size_)*/{}};
1202
1203 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1204 _this->_impl_.node_id_ = from._impl_.node_id_;
1205 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferNodeInputInfo)
1206 }
1207
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1208 inline void GraphTransferNodeInputInfo::SharedCtor(
1209 ::_pb::Arena* arena, bool is_message_owned) {
1210 (void)arena;
1211 (void)is_message_owned;
1212 new (&_impl_) Impl_{
1213 decltype(_impl_.node_input_){arena}
1214 , decltype(_impl_.node_id_){0}
1215 , /*decltype(_impl_._cached_size_)*/{}
1216 };
1217 }
1218
~GraphTransferNodeInputInfo()1219 GraphTransferNodeInputInfo::~GraphTransferNodeInputInfo() {
1220 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferNodeInputInfo)
1221 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1222 (void)arena;
1223 return;
1224 }
1225 SharedDtor();
1226 }
1227
SharedDtor()1228 inline void GraphTransferNodeInputInfo::SharedDtor() {
1229 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1230 _impl_.node_input_.~RepeatedPtrField();
1231 }
1232
SetCachedSize(int size) const1233 void GraphTransferNodeInputInfo::SetCachedSize(int size) const {
1234 _impl_._cached_size_.Set(size);
1235 }
1236
Clear()1237 void GraphTransferNodeInputInfo::Clear() {
1238 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferNodeInputInfo)
1239 ::uint32_t cached_has_bits = 0;
1240 // Prevent compiler warnings about cached_has_bits being unused
1241 (void) cached_has_bits;
1242
1243 _impl_.node_input_.Clear();
1244 _impl_.node_id_ = 0;
1245 _internal_metadata_.Clear<std::string>();
1246 }
1247
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1248 const char* GraphTransferNodeInputInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1249 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1250 while (!ctx->Done(&ptr)) {
1251 ::uint32_t tag;
1252 ptr = ::_pbi::ReadTag(ptr, &tag);
1253 switch (tag >> 3) {
1254 // int32 node_id = 1;
1255 case 1:
1256 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1257 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1258 CHK_(ptr);
1259 } else {
1260 goto handle_unusual;
1261 }
1262 continue;
1263 // repeated .tensorflow.GraphTransferNodeInput node_input = 2;
1264 case 2:
1265 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1266 ptr -= 1;
1267 do {
1268 ptr += 1;
1269 ptr = ctx->ParseMessage(_internal_add_node_input(), ptr);
1270 CHK_(ptr);
1271 if (!ctx->DataAvailable(ptr)) break;
1272 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1273 } else {
1274 goto handle_unusual;
1275 }
1276 continue;
1277 default:
1278 goto handle_unusual;
1279 } // switch
1280 handle_unusual:
1281 if ((tag == 0) || ((tag & 7) == 4)) {
1282 CHK_(ptr);
1283 ctx->SetLastTag(tag);
1284 goto message_done;
1285 }
1286 ptr = UnknownFieldParse(
1287 tag,
1288 _internal_metadata_.mutable_unknown_fields<std::string>(),
1289 ptr, ctx);
1290 CHK_(ptr != nullptr);
1291 } // while
1292 message_done:
1293 return ptr;
1294 failure:
1295 ptr = nullptr;
1296 goto message_done;
1297 #undef CHK_
1298 }
1299
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1300 ::uint8_t* GraphTransferNodeInputInfo::_InternalSerialize(
1301 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1302 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferNodeInputInfo)
1303 ::uint32_t cached_has_bits = 0;
1304 (void) cached_has_bits;
1305
1306 // int32 node_id = 1;
1307 if (this->_internal_node_id() != 0) {
1308 target = stream->EnsureSpace(target);
1309 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_node_id(), target);
1310 }
1311
1312 // repeated .tensorflow.GraphTransferNodeInput node_input = 2;
1313 for (unsigned i = 0,
1314 n = static_cast<unsigned>(this->_internal_node_input_size()); i < n; i++) {
1315 const auto& repfield = this->_internal_node_input(i);
1316 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1317 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1318 }
1319
1320 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1321 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1322 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1323 }
1324 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferNodeInputInfo)
1325 return target;
1326 }
1327
ByteSizeLong() const1328 size_t GraphTransferNodeInputInfo::ByteSizeLong() const {
1329 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferNodeInputInfo)
1330 size_t total_size = 0;
1331
1332 ::uint32_t cached_has_bits = 0;
1333 // Prevent compiler warnings about cached_has_bits being unused
1334 (void) cached_has_bits;
1335
1336 // repeated .tensorflow.GraphTransferNodeInput node_input = 2;
1337 total_size += 1UL * this->_internal_node_input_size();
1338 for (const auto& msg : this->_impl_.node_input_) {
1339 total_size +=
1340 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1341 }
1342
1343 // int32 node_id = 1;
1344 if (this->_internal_node_id() != 0) {
1345 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
1346 }
1347
1348 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1349 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1350 }
1351 int cached_size = ::_pbi::ToCachedSize(total_size);
1352 SetCachedSize(cached_size);
1353 return total_size;
1354 }
1355
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1356 void GraphTransferNodeInputInfo::CheckTypeAndMergeFrom(
1357 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1358 MergeFrom(*::_pbi::DownCast<const GraphTransferNodeInputInfo*>(
1359 &from));
1360 }
1361
MergeFrom(const GraphTransferNodeInputInfo & from)1362 void GraphTransferNodeInputInfo::MergeFrom(const GraphTransferNodeInputInfo& from) {
1363 GraphTransferNodeInputInfo* const _this = this;
1364 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferNodeInputInfo)
1365 GOOGLE_DCHECK_NE(&from, _this);
1366 ::uint32_t cached_has_bits = 0;
1367 (void) cached_has_bits;
1368
1369 _this->_impl_.node_input_.MergeFrom(from._impl_.node_input_);
1370 if (from._internal_node_id() != 0) {
1371 _this->_internal_set_node_id(from._internal_node_id());
1372 }
1373 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1374 }
1375
CopyFrom(const GraphTransferNodeInputInfo & from)1376 void GraphTransferNodeInputInfo::CopyFrom(const GraphTransferNodeInputInfo& from) {
1377 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferNodeInputInfo)
1378 if (&from == this) return;
1379 Clear();
1380 MergeFrom(from);
1381 }
1382
IsInitialized() const1383 bool GraphTransferNodeInputInfo::IsInitialized() const {
1384 return true;
1385 }
1386
InternalSwap(GraphTransferNodeInputInfo * other)1387 void GraphTransferNodeInputInfo::InternalSwap(GraphTransferNodeInputInfo* other) {
1388 using std::swap;
1389 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1390 _impl_.node_input_.InternalSwap(&other->_impl_.node_input_);
1391 swap(_impl_.node_id_, other->_impl_.node_id_);
1392 }
1393
GetTypeName() const1394 std::string GraphTransferNodeInputInfo::GetTypeName() const {
1395 return "tensorflow.GraphTransferNodeInputInfo";
1396 }
1397
1398
1399 // ===================================================================
1400
1401 class GraphTransferNodeOutputInfo::_Internal {
1402 public:
1403 };
1404
GraphTransferNodeOutputInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1405 GraphTransferNodeOutputInfo::GraphTransferNodeOutputInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1406 bool is_message_owned)
1407 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1408 SharedCtor(arena, is_message_owned);
1409 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferNodeOutputInfo)
1410 }
GraphTransferNodeOutputInfo(const GraphTransferNodeOutputInfo & from)1411 GraphTransferNodeOutputInfo::GraphTransferNodeOutputInfo(const GraphTransferNodeOutputInfo& from)
1412 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1413 GraphTransferNodeOutputInfo* const _this = this; (void)_this;
1414 new (&_impl_) Impl_{
1415 decltype(_impl_.max_byte_size_){from._impl_.max_byte_size_}
1416 , /*decltype(_impl_._max_byte_size_cached_byte_size_)*/{0}
1417 , decltype(_impl_.node_id_){}
1418 , /*decltype(_impl_._cached_size_)*/{}};
1419
1420 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1421 _this->_impl_.node_id_ = from._impl_.node_id_;
1422 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferNodeOutputInfo)
1423 }
1424
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1425 inline void GraphTransferNodeOutputInfo::SharedCtor(
1426 ::_pb::Arena* arena, bool is_message_owned) {
1427 (void)arena;
1428 (void)is_message_owned;
1429 new (&_impl_) Impl_{
1430 decltype(_impl_.max_byte_size_){arena}
1431 , /*decltype(_impl_._max_byte_size_cached_byte_size_)*/{0}
1432 , decltype(_impl_.node_id_){0}
1433 , /*decltype(_impl_._cached_size_)*/{}
1434 };
1435 }
1436
~GraphTransferNodeOutputInfo()1437 GraphTransferNodeOutputInfo::~GraphTransferNodeOutputInfo() {
1438 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferNodeOutputInfo)
1439 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1440 (void)arena;
1441 return;
1442 }
1443 SharedDtor();
1444 }
1445
SharedDtor()1446 inline void GraphTransferNodeOutputInfo::SharedDtor() {
1447 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1448 _impl_.max_byte_size_.~RepeatedField();
1449 }
1450
SetCachedSize(int size) const1451 void GraphTransferNodeOutputInfo::SetCachedSize(int size) const {
1452 _impl_._cached_size_.Set(size);
1453 }
1454
Clear()1455 void GraphTransferNodeOutputInfo::Clear() {
1456 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferNodeOutputInfo)
1457 ::uint32_t cached_has_bits = 0;
1458 // Prevent compiler warnings about cached_has_bits being unused
1459 (void) cached_has_bits;
1460
1461 _impl_.max_byte_size_.Clear();
1462 _impl_.node_id_ = 0;
1463 _internal_metadata_.Clear<std::string>();
1464 }
1465
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1466 const char* GraphTransferNodeOutputInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1467 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1468 while (!ctx->Done(&ptr)) {
1469 ::uint32_t tag;
1470 ptr = ::_pbi::ReadTag(ptr, &tag);
1471 switch (tag >> 3) {
1472 // int32 node_id = 1;
1473 case 1:
1474 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1475 _impl_.node_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1476 CHK_(ptr);
1477 } else {
1478 goto handle_unusual;
1479 }
1480 continue;
1481 // repeated int32 max_byte_size = 2;
1482 case 2:
1483 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1484 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_max_byte_size(), ptr, ctx);
1485 CHK_(ptr);
1486 } else if (static_cast<::uint8_t>(tag) == 16) {
1487 _internal_add_max_byte_size(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
1488 CHK_(ptr);
1489 } else {
1490 goto handle_unusual;
1491 }
1492 continue;
1493 default:
1494 goto handle_unusual;
1495 } // switch
1496 handle_unusual:
1497 if ((tag == 0) || ((tag & 7) == 4)) {
1498 CHK_(ptr);
1499 ctx->SetLastTag(tag);
1500 goto message_done;
1501 }
1502 ptr = UnknownFieldParse(
1503 tag,
1504 _internal_metadata_.mutable_unknown_fields<std::string>(),
1505 ptr, ctx);
1506 CHK_(ptr != nullptr);
1507 } // while
1508 message_done:
1509 return ptr;
1510 failure:
1511 ptr = nullptr;
1512 goto message_done;
1513 #undef CHK_
1514 }
1515
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1516 ::uint8_t* GraphTransferNodeOutputInfo::_InternalSerialize(
1517 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1518 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferNodeOutputInfo)
1519 ::uint32_t cached_has_bits = 0;
1520 (void) cached_has_bits;
1521
1522 // int32 node_id = 1;
1523 if (this->_internal_node_id() != 0) {
1524 target = stream->EnsureSpace(target);
1525 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_node_id(), target);
1526 }
1527
1528 // repeated int32 max_byte_size = 2;
1529 {
1530 int byte_size = _impl_._max_byte_size_cached_byte_size_.load(std::memory_order_relaxed);
1531 if (byte_size > 0) {
1532 target = stream->WriteInt32Packed(
1533 2, _internal_max_byte_size(), byte_size, target);
1534 }
1535 }
1536
1537 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1538 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1539 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1540 }
1541 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferNodeOutputInfo)
1542 return target;
1543 }
1544
ByteSizeLong() const1545 size_t GraphTransferNodeOutputInfo::ByteSizeLong() const {
1546 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferNodeOutputInfo)
1547 size_t total_size = 0;
1548
1549 ::uint32_t cached_has_bits = 0;
1550 // Prevent compiler warnings about cached_has_bits being unused
1551 (void) cached_has_bits;
1552
1553 // repeated int32 max_byte_size = 2;
1554 {
1555 size_t data_size = ::_pbi::WireFormatLite::
1556 Int32Size(this->_impl_.max_byte_size_);
1557 if (data_size > 0) {
1558 total_size += 1 +
1559 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
1560 }
1561 int cached_size = ::_pbi::ToCachedSize(data_size);
1562 _impl_._max_byte_size_cached_byte_size_.store(cached_size,
1563 std::memory_order_relaxed);
1564 total_size += data_size;
1565 }
1566
1567 // int32 node_id = 1;
1568 if (this->_internal_node_id() != 0) {
1569 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_node_id());
1570 }
1571
1572 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1573 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1574 }
1575 int cached_size = ::_pbi::ToCachedSize(total_size);
1576 SetCachedSize(cached_size);
1577 return total_size;
1578 }
1579
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1580 void GraphTransferNodeOutputInfo::CheckTypeAndMergeFrom(
1581 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1582 MergeFrom(*::_pbi::DownCast<const GraphTransferNodeOutputInfo*>(
1583 &from));
1584 }
1585
MergeFrom(const GraphTransferNodeOutputInfo & from)1586 void GraphTransferNodeOutputInfo::MergeFrom(const GraphTransferNodeOutputInfo& from) {
1587 GraphTransferNodeOutputInfo* const _this = this;
1588 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferNodeOutputInfo)
1589 GOOGLE_DCHECK_NE(&from, _this);
1590 ::uint32_t cached_has_bits = 0;
1591 (void) cached_has_bits;
1592
1593 _this->_impl_.max_byte_size_.MergeFrom(from._impl_.max_byte_size_);
1594 if (from._internal_node_id() != 0) {
1595 _this->_internal_set_node_id(from._internal_node_id());
1596 }
1597 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1598 }
1599
CopyFrom(const GraphTransferNodeOutputInfo & from)1600 void GraphTransferNodeOutputInfo::CopyFrom(const GraphTransferNodeOutputInfo& from) {
1601 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferNodeOutputInfo)
1602 if (&from == this) return;
1603 Clear();
1604 MergeFrom(from);
1605 }
1606
IsInitialized() const1607 bool GraphTransferNodeOutputInfo::IsInitialized() const {
1608 return true;
1609 }
1610
InternalSwap(GraphTransferNodeOutputInfo * other)1611 void GraphTransferNodeOutputInfo::InternalSwap(GraphTransferNodeOutputInfo* other) {
1612 using std::swap;
1613 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1614 _impl_.max_byte_size_.InternalSwap(&other->_impl_.max_byte_size_);
1615 swap(_impl_.node_id_, other->_impl_.node_id_);
1616 }
1617
GetTypeName() const1618 std::string GraphTransferNodeOutputInfo::GetTypeName() const {
1619 return "tensorflow.GraphTransferNodeOutputInfo";
1620 }
1621
1622
1623 // ===================================================================
1624
1625 class GraphTransferGraphInputNodeInfo::_Internal {
1626 public:
1627 };
1628
GraphTransferGraphInputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1629 GraphTransferGraphInputNodeInfo::GraphTransferGraphInputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1630 bool is_message_owned)
1631 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1632 SharedCtor(arena, is_message_owned);
1633 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferGraphInputNodeInfo)
1634 }
GraphTransferGraphInputNodeInfo(const GraphTransferGraphInputNodeInfo & from)1635 GraphTransferGraphInputNodeInfo::GraphTransferGraphInputNodeInfo(const GraphTransferGraphInputNodeInfo& from)
1636 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1637 GraphTransferGraphInputNodeInfo* const _this = this; (void)_this;
1638 new (&_impl_) Impl_{
1639 decltype(_impl_.shape_){from._impl_.shape_}
1640 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
1641 , decltype(_impl_.name_){}
1642 , decltype(_impl_.dtype_){}
1643 , /*decltype(_impl_._cached_size_)*/{}};
1644
1645 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1646 _impl_.name_.InitDefault();
1647 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1648 _impl_.name_.Set("", GetArenaForAllocation());
1649 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1650 if (!from._internal_name().empty()) {
1651 _this->_impl_.name_.Set(from._internal_name(),
1652 _this->GetArenaForAllocation());
1653 }
1654 _this->_impl_.dtype_ = from._impl_.dtype_;
1655 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferGraphInputNodeInfo)
1656 }
1657
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1658 inline void GraphTransferGraphInputNodeInfo::SharedCtor(
1659 ::_pb::Arena* arena, bool is_message_owned) {
1660 (void)arena;
1661 (void)is_message_owned;
1662 new (&_impl_) Impl_{
1663 decltype(_impl_.shape_){arena}
1664 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
1665 , decltype(_impl_.name_){}
1666 , decltype(_impl_.dtype_){0}
1667 , /*decltype(_impl_._cached_size_)*/{}
1668 };
1669 _impl_.name_.InitDefault();
1670 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1671 _impl_.name_.Set("", GetArenaForAllocation());
1672 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1673 }
1674
~GraphTransferGraphInputNodeInfo()1675 GraphTransferGraphInputNodeInfo::~GraphTransferGraphInputNodeInfo() {
1676 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferGraphInputNodeInfo)
1677 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1678 (void)arena;
1679 return;
1680 }
1681 SharedDtor();
1682 }
1683
SharedDtor()1684 inline void GraphTransferGraphInputNodeInfo::SharedDtor() {
1685 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1686 _impl_.shape_.~RepeatedField();
1687 _impl_.name_.Destroy();
1688 }
1689
SetCachedSize(int size) const1690 void GraphTransferGraphInputNodeInfo::SetCachedSize(int size) const {
1691 _impl_._cached_size_.Set(size);
1692 }
1693
Clear()1694 void GraphTransferGraphInputNodeInfo::Clear() {
1695 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferGraphInputNodeInfo)
1696 ::uint32_t cached_has_bits = 0;
1697 // Prevent compiler warnings about cached_has_bits being unused
1698 (void) cached_has_bits;
1699
1700 _impl_.shape_.Clear();
1701 _impl_.name_.ClearToEmpty();
1702 _impl_.dtype_ = 0;
1703 _internal_metadata_.Clear<std::string>();
1704 }
1705
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1706 const char* GraphTransferGraphInputNodeInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1707 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1708 while (!ctx->Done(&ptr)) {
1709 ::uint32_t tag;
1710 ptr = ::_pbi::ReadTag(ptr, &tag);
1711 switch (tag >> 3) {
1712 // string name = 1;
1713 case 1:
1714 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1715 auto str = _internal_mutable_name();
1716 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1717 CHK_(ptr);
1718 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1719 } else {
1720 goto handle_unusual;
1721 }
1722 continue;
1723 // repeated int64 shape = 2;
1724 case 2:
1725 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1726 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_shape(), ptr, ctx);
1727 CHK_(ptr);
1728 } else if (static_cast<::uint8_t>(tag) == 16) {
1729 _internal_add_shape(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1730 CHK_(ptr);
1731 } else {
1732 goto handle_unusual;
1733 }
1734 continue;
1735 // .tensorflow.DataType dtype = 3;
1736 case 3:
1737 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1738 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1739 CHK_(ptr);
1740 _internal_set_dtype(static_cast<::tensorflow::DataType>(val));
1741 } else {
1742 goto handle_unusual;
1743 }
1744 continue;
1745 default:
1746 goto handle_unusual;
1747 } // switch
1748 handle_unusual:
1749 if ((tag == 0) || ((tag & 7) == 4)) {
1750 CHK_(ptr);
1751 ctx->SetLastTag(tag);
1752 goto message_done;
1753 }
1754 ptr = UnknownFieldParse(
1755 tag,
1756 _internal_metadata_.mutable_unknown_fields<std::string>(),
1757 ptr, ctx);
1758 CHK_(ptr != nullptr);
1759 } // while
1760 message_done:
1761 return ptr;
1762 failure:
1763 ptr = nullptr;
1764 goto message_done;
1765 #undef CHK_
1766 }
1767
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1768 ::uint8_t* GraphTransferGraphInputNodeInfo::_InternalSerialize(
1769 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1770 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferGraphInputNodeInfo)
1771 ::uint32_t cached_has_bits = 0;
1772 (void) cached_has_bits;
1773
1774 // string name = 1;
1775 if (!this->_internal_name().empty()) {
1776 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1777 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
1778 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1779 "tensorflow.GraphTransferGraphInputNodeInfo.name");
1780 target = stream->WriteStringMaybeAliased(
1781 1, this->_internal_name(), target);
1782 }
1783
1784 // repeated int64 shape = 2;
1785 {
1786 int byte_size = _impl_._shape_cached_byte_size_.load(std::memory_order_relaxed);
1787 if (byte_size > 0) {
1788 target = stream->WriteInt64Packed(
1789 2, _internal_shape(), byte_size, target);
1790 }
1791 }
1792
1793 // .tensorflow.DataType dtype = 3;
1794 if (this->_internal_dtype() != 0) {
1795 target = stream->EnsureSpace(target);
1796 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1797 3, this->_internal_dtype(), target);
1798 }
1799
1800 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1801 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1802 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1803 }
1804 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferGraphInputNodeInfo)
1805 return target;
1806 }
1807
ByteSizeLong() const1808 size_t GraphTransferGraphInputNodeInfo::ByteSizeLong() const {
1809 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferGraphInputNodeInfo)
1810 size_t total_size = 0;
1811
1812 ::uint32_t cached_has_bits = 0;
1813 // Prevent compiler warnings about cached_has_bits being unused
1814 (void) cached_has_bits;
1815
1816 // repeated int64 shape = 2;
1817 {
1818 size_t data_size = ::_pbi::WireFormatLite::
1819 Int64Size(this->_impl_.shape_);
1820 if (data_size > 0) {
1821 total_size += 1 +
1822 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
1823 }
1824 int cached_size = ::_pbi::ToCachedSize(data_size);
1825 _impl_._shape_cached_byte_size_.store(cached_size,
1826 std::memory_order_relaxed);
1827 total_size += data_size;
1828 }
1829
1830 // string name = 1;
1831 if (!this->_internal_name().empty()) {
1832 total_size += 1 +
1833 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1834 this->_internal_name());
1835 }
1836
1837 // .tensorflow.DataType dtype = 3;
1838 if (this->_internal_dtype() != 0) {
1839 total_size += 1 +
1840 ::_pbi::WireFormatLite::EnumSize(this->_internal_dtype());
1841 }
1842
1843 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1844 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1845 }
1846 int cached_size = ::_pbi::ToCachedSize(total_size);
1847 SetCachedSize(cached_size);
1848 return total_size;
1849 }
1850
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1851 void GraphTransferGraphInputNodeInfo::CheckTypeAndMergeFrom(
1852 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1853 MergeFrom(*::_pbi::DownCast<const GraphTransferGraphInputNodeInfo*>(
1854 &from));
1855 }
1856
MergeFrom(const GraphTransferGraphInputNodeInfo & from)1857 void GraphTransferGraphInputNodeInfo::MergeFrom(const GraphTransferGraphInputNodeInfo& from) {
1858 GraphTransferGraphInputNodeInfo* const _this = this;
1859 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferGraphInputNodeInfo)
1860 GOOGLE_DCHECK_NE(&from, _this);
1861 ::uint32_t cached_has_bits = 0;
1862 (void) cached_has_bits;
1863
1864 _this->_impl_.shape_.MergeFrom(from._impl_.shape_);
1865 if (!from._internal_name().empty()) {
1866 _this->_internal_set_name(from._internal_name());
1867 }
1868 if (from._internal_dtype() != 0) {
1869 _this->_internal_set_dtype(from._internal_dtype());
1870 }
1871 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1872 }
1873
CopyFrom(const GraphTransferGraphInputNodeInfo & from)1874 void GraphTransferGraphInputNodeInfo::CopyFrom(const GraphTransferGraphInputNodeInfo& from) {
1875 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferGraphInputNodeInfo)
1876 if (&from == this) return;
1877 Clear();
1878 MergeFrom(from);
1879 }
1880
IsInitialized() const1881 bool GraphTransferGraphInputNodeInfo::IsInitialized() const {
1882 return true;
1883 }
1884
InternalSwap(GraphTransferGraphInputNodeInfo * other)1885 void GraphTransferGraphInputNodeInfo::InternalSwap(GraphTransferGraphInputNodeInfo* other) {
1886 using std::swap;
1887 auto* lhs_arena = GetArenaForAllocation();
1888 auto* rhs_arena = other->GetArenaForAllocation();
1889 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1890 _impl_.shape_.InternalSwap(&other->_impl_.shape_);
1891 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1892 &_impl_.name_, lhs_arena,
1893 &other->_impl_.name_, rhs_arena
1894 );
1895 swap(_impl_.dtype_, other->_impl_.dtype_);
1896 }
1897
GetTypeName() const1898 std::string GraphTransferGraphInputNodeInfo::GetTypeName() const {
1899 return "tensorflow.GraphTransferGraphInputNodeInfo";
1900 }
1901
1902
1903 // ===================================================================
1904
1905 class GraphTransferGraphOutputNodeInfo::_Internal {
1906 public:
1907 };
1908
GraphTransferGraphOutputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1909 GraphTransferGraphOutputNodeInfo::GraphTransferGraphOutputNodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1910 bool is_message_owned)
1911 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1912 SharedCtor(arena, is_message_owned);
1913 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferGraphOutputNodeInfo)
1914 }
GraphTransferGraphOutputNodeInfo(const GraphTransferGraphOutputNodeInfo & from)1915 GraphTransferGraphOutputNodeInfo::GraphTransferGraphOutputNodeInfo(const GraphTransferGraphOutputNodeInfo& from)
1916 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1917 GraphTransferGraphOutputNodeInfo* const _this = this; (void)_this;
1918 new (&_impl_) Impl_{
1919 decltype(_impl_.shape_){from._impl_.shape_}
1920 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
1921 , decltype(_impl_.name_){}
1922 , decltype(_impl_.dtype_){}
1923 , /*decltype(_impl_._cached_size_)*/{}};
1924
1925 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1926 _impl_.name_.InitDefault();
1927 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1928 _impl_.name_.Set("", GetArenaForAllocation());
1929 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1930 if (!from._internal_name().empty()) {
1931 _this->_impl_.name_.Set(from._internal_name(),
1932 _this->GetArenaForAllocation());
1933 }
1934 _this->_impl_.dtype_ = from._impl_.dtype_;
1935 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferGraphOutputNodeInfo)
1936 }
1937
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1938 inline void GraphTransferGraphOutputNodeInfo::SharedCtor(
1939 ::_pb::Arena* arena, bool is_message_owned) {
1940 (void)arena;
1941 (void)is_message_owned;
1942 new (&_impl_) Impl_{
1943 decltype(_impl_.shape_){arena}
1944 , /*decltype(_impl_._shape_cached_byte_size_)*/{0}
1945 , decltype(_impl_.name_){}
1946 , decltype(_impl_.dtype_){0}
1947 , /*decltype(_impl_._cached_size_)*/{}
1948 };
1949 _impl_.name_.InitDefault();
1950 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1951 _impl_.name_.Set("", GetArenaForAllocation());
1952 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1953 }
1954
~GraphTransferGraphOutputNodeInfo()1955 GraphTransferGraphOutputNodeInfo::~GraphTransferGraphOutputNodeInfo() {
1956 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferGraphOutputNodeInfo)
1957 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1958 (void)arena;
1959 return;
1960 }
1961 SharedDtor();
1962 }
1963
SharedDtor()1964 inline void GraphTransferGraphOutputNodeInfo::SharedDtor() {
1965 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1966 _impl_.shape_.~RepeatedField();
1967 _impl_.name_.Destroy();
1968 }
1969
SetCachedSize(int size) const1970 void GraphTransferGraphOutputNodeInfo::SetCachedSize(int size) const {
1971 _impl_._cached_size_.Set(size);
1972 }
1973
Clear()1974 void GraphTransferGraphOutputNodeInfo::Clear() {
1975 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferGraphOutputNodeInfo)
1976 ::uint32_t cached_has_bits = 0;
1977 // Prevent compiler warnings about cached_has_bits being unused
1978 (void) cached_has_bits;
1979
1980 _impl_.shape_.Clear();
1981 _impl_.name_.ClearToEmpty();
1982 _impl_.dtype_ = 0;
1983 _internal_metadata_.Clear<std::string>();
1984 }
1985
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1986 const char* GraphTransferGraphOutputNodeInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1987 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1988 while (!ctx->Done(&ptr)) {
1989 ::uint32_t tag;
1990 ptr = ::_pbi::ReadTag(ptr, &tag);
1991 switch (tag >> 3) {
1992 // string name = 1;
1993 case 1:
1994 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1995 auto str = _internal_mutable_name();
1996 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1997 CHK_(ptr);
1998 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1999 } else {
2000 goto handle_unusual;
2001 }
2002 continue;
2003 // repeated int64 shape = 2;
2004 case 2:
2005 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2006 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_shape(), ptr, ctx);
2007 CHK_(ptr);
2008 } else if (static_cast<::uint8_t>(tag) == 16) {
2009 _internal_add_shape(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
2010 CHK_(ptr);
2011 } else {
2012 goto handle_unusual;
2013 }
2014 continue;
2015 // .tensorflow.DataType dtype = 3;
2016 case 3:
2017 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2018 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2019 CHK_(ptr);
2020 _internal_set_dtype(static_cast<::tensorflow::DataType>(val));
2021 } else {
2022 goto handle_unusual;
2023 }
2024 continue;
2025 default:
2026 goto handle_unusual;
2027 } // switch
2028 handle_unusual:
2029 if ((tag == 0) || ((tag & 7) == 4)) {
2030 CHK_(ptr);
2031 ctx->SetLastTag(tag);
2032 goto message_done;
2033 }
2034 ptr = UnknownFieldParse(
2035 tag,
2036 _internal_metadata_.mutable_unknown_fields<std::string>(),
2037 ptr, ctx);
2038 CHK_(ptr != nullptr);
2039 } // while
2040 message_done:
2041 return ptr;
2042 failure:
2043 ptr = nullptr;
2044 goto message_done;
2045 #undef CHK_
2046 }
2047
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2048 ::uint8_t* GraphTransferGraphOutputNodeInfo::_InternalSerialize(
2049 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2050 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferGraphOutputNodeInfo)
2051 ::uint32_t cached_has_bits = 0;
2052 (void) cached_has_bits;
2053
2054 // string name = 1;
2055 if (!this->_internal_name().empty()) {
2056 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2057 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
2058 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2059 "tensorflow.GraphTransferGraphOutputNodeInfo.name");
2060 target = stream->WriteStringMaybeAliased(
2061 1, this->_internal_name(), target);
2062 }
2063
2064 // repeated int64 shape = 2;
2065 {
2066 int byte_size = _impl_._shape_cached_byte_size_.load(std::memory_order_relaxed);
2067 if (byte_size > 0) {
2068 target = stream->WriteInt64Packed(
2069 2, _internal_shape(), byte_size, target);
2070 }
2071 }
2072
2073 // .tensorflow.DataType dtype = 3;
2074 if (this->_internal_dtype() != 0) {
2075 target = stream->EnsureSpace(target);
2076 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2077 3, this->_internal_dtype(), target);
2078 }
2079
2080 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2081 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2082 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2083 }
2084 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferGraphOutputNodeInfo)
2085 return target;
2086 }
2087
ByteSizeLong() const2088 size_t GraphTransferGraphOutputNodeInfo::ByteSizeLong() const {
2089 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferGraphOutputNodeInfo)
2090 size_t total_size = 0;
2091
2092 ::uint32_t cached_has_bits = 0;
2093 // Prevent compiler warnings about cached_has_bits being unused
2094 (void) cached_has_bits;
2095
2096 // repeated int64 shape = 2;
2097 {
2098 size_t data_size = ::_pbi::WireFormatLite::
2099 Int64Size(this->_impl_.shape_);
2100 if (data_size > 0) {
2101 total_size += 1 +
2102 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
2103 }
2104 int cached_size = ::_pbi::ToCachedSize(data_size);
2105 _impl_._shape_cached_byte_size_.store(cached_size,
2106 std::memory_order_relaxed);
2107 total_size += data_size;
2108 }
2109
2110 // string name = 1;
2111 if (!this->_internal_name().empty()) {
2112 total_size += 1 +
2113 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2114 this->_internal_name());
2115 }
2116
2117 // .tensorflow.DataType dtype = 3;
2118 if (this->_internal_dtype() != 0) {
2119 total_size += 1 +
2120 ::_pbi::WireFormatLite::EnumSize(this->_internal_dtype());
2121 }
2122
2123 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2124 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2125 }
2126 int cached_size = ::_pbi::ToCachedSize(total_size);
2127 SetCachedSize(cached_size);
2128 return total_size;
2129 }
2130
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2131 void GraphTransferGraphOutputNodeInfo::CheckTypeAndMergeFrom(
2132 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2133 MergeFrom(*::_pbi::DownCast<const GraphTransferGraphOutputNodeInfo*>(
2134 &from));
2135 }
2136
MergeFrom(const GraphTransferGraphOutputNodeInfo & from)2137 void GraphTransferGraphOutputNodeInfo::MergeFrom(const GraphTransferGraphOutputNodeInfo& from) {
2138 GraphTransferGraphOutputNodeInfo* const _this = this;
2139 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferGraphOutputNodeInfo)
2140 GOOGLE_DCHECK_NE(&from, _this);
2141 ::uint32_t cached_has_bits = 0;
2142 (void) cached_has_bits;
2143
2144 _this->_impl_.shape_.MergeFrom(from._impl_.shape_);
2145 if (!from._internal_name().empty()) {
2146 _this->_internal_set_name(from._internal_name());
2147 }
2148 if (from._internal_dtype() != 0) {
2149 _this->_internal_set_dtype(from._internal_dtype());
2150 }
2151 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2152 }
2153
CopyFrom(const GraphTransferGraphOutputNodeInfo & from)2154 void GraphTransferGraphOutputNodeInfo::CopyFrom(const GraphTransferGraphOutputNodeInfo& from) {
2155 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferGraphOutputNodeInfo)
2156 if (&from == this) return;
2157 Clear();
2158 MergeFrom(from);
2159 }
2160
IsInitialized() const2161 bool GraphTransferGraphOutputNodeInfo::IsInitialized() const {
2162 return true;
2163 }
2164
InternalSwap(GraphTransferGraphOutputNodeInfo * other)2165 void GraphTransferGraphOutputNodeInfo::InternalSwap(GraphTransferGraphOutputNodeInfo* other) {
2166 using std::swap;
2167 auto* lhs_arena = GetArenaForAllocation();
2168 auto* rhs_arena = other->GetArenaForAllocation();
2169 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2170 _impl_.shape_.InternalSwap(&other->_impl_.shape_);
2171 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2172 &_impl_.name_, lhs_arena,
2173 &other->_impl_.name_, rhs_arena
2174 );
2175 swap(_impl_.dtype_, other->_impl_.dtype_);
2176 }
2177
GetTypeName() const2178 std::string GraphTransferGraphOutputNodeInfo::GetTypeName() const {
2179 return "tensorflow.GraphTransferGraphOutputNodeInfo";
2180 }
2181
2182
2183 // ===================================================================
2184
2185 class GraphTransferInfo::_Internal {
2186 public:
2187 };
2188
GraphTransferInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2189 GraphTransferInfo::GraphTransferInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2190 bool is_message_owned)
2191 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2192 SharedCtor(arena, is_message_owned);
2193 // @@protoc_insertion_point(arena_constructor:tensorflow.GraphTransferInfo)
2194 }
GraphTransferInfo(const GraphTransferInfo & from)2195 GraphTransferInfo::GraphTransferInfo(const GraphTransferInfo& from)
2196 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2197 GraphTransferInfo* const _this = this; (void)_this;
2198 new (&_impl_) Impl_{
2199 decltype(_impl_.node_info_){from._impl_.node_info_}
2200 , decltype(_impl_.const_node_info_){from._impl_.const_node_info_}
2201 , decltype(_impl_.node_input_info_){from._impl_.node_input_info_}
2202 , decltype(_impl_.node_output_info_){from._impl_.node_output_info_}
2203 , decltype(_impl_.graph_input_node_info_){from._impl_.graph_input_node_info_}
2204 , decltype(_impl_.graph_output_node_info_){from._impl_.graph_output_node_info_}
2205 , decltype(_impl_.destination_){}
2206 , /*decltype(_impl_._cached_size_)*/{}};
2207
2208 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2209 _this->_impl_.destination_ = from._impl_.destination_;
2210 // @@protoc_insertion_point(copy_constructor:tensorflow.GraphTransferInfo)
2211 }
2212
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2213 inline void GraphTransferInfo::SharedCtor(
2214 ::_pb::Arena* arena, bool is_message_owned) {
2215 (void)arena;
2216 (void)is_message_owned;
2217 new (&_impl_) Impl_{
2218 decltype(_impl_.node_info_){arena}
2219 , decltype(_impl_.const_node_info_){arena}
2220 , decltype(_impl_.node_input_info_){arena}
2221 , decltype(_impl_.node_output_info_){arena}
2222 , decltype(_impl_.graph_input_node_info_){arena}
2223 , decltype(_impl_.graph_output_node_info_){arena}
2224 , decltype(_impl_.destination_){0}
2225 , /*decltype(_impl_._cached_size_)*/{}
2226 };
2227 }
2228
~GraphTransferInfo()2229 GraphTransferInfo::~GraphTransferInfo() {
2230 // @@protoc_insertion_point(destructor:tensorflow.GraphTransferInfo)
2231 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2232 (void)arena;
2233 return;
2234 }
2235 SharedDtor();
2236 }
2237
SharedDtor()2238 inline void GraphTransferInfo::SharedDtor() {
2239 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2240 _impl_.node_info_.~RepeatedPtrField();
2241 _impl_.const_node_info_.~RepeatedPtrField();
2242 _impl_.node_input_info_.~RepeatedPtrField();
2243 _impl_.node_output_info_.~RepeatedPtrField();
2244 _impl_.graph_input_node_info_.~RepeatedPtrField();
2245 _impl_.graph_output_node_info_.~RepeatedPtrField();
2246 }
2247
SetCachedSize(int size) const2248 void GraphTransferInfo::SetCachedSize(int size) const {
2249 _impl_._cached_size_.Set(size);
2250 }
2251
Clear()2252 void GraphTransferInfo::Clear() {
2253 // @@protoc_insertion_point(message_clear_start:tensorflow.GraphTransferInfo)
2254 ::uint32_t cached_has_bits = 0;
2255 // Prevent compiler warnings about cached_has_bits being unused
2256 (void) cached_has_bits;
2257
2258 _impl_.node_info_.Clear();
2259 _impl_.const_node_info_.Clear();
2260 _impl_.node_input_info_.Clear();
2261 _impl_.node_output_info_.Clear();
2262 _impl_.graph_input_node_info_.Clear();
2263 _impl_.graph_output_node_info_.Clear();
2264 _impl_.destination_ = 0;
2265 _internal_metadata_.Clear<std::string>();
2266 }
2267
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2268 const char* GraphTransferInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2269 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2270 while (!ctx->Done(&ptr)) {
2271 ::uint32_t tag;
2272 ptr = ::_pbi::ReadTag(ptr, &tag);
2273 switch (tag >> 3) {
2274 // repeated .tensorflow.GraphTransferNodeInfo node_info = 1;
2275 case 1:
2276 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2277 ptr -= 1;
2278 do {
2279 ptr += 1;
2280 ptr = ctx->ParseMessage(_internal_add_node_info(), ptr);
2281 CHK_(ptr);
2282 if (!ctx->DataAvailable(ptr)) break;
2283 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
2284 } else {
2285 goto handle_unusual;
2286 }
2287 continue;
2288 // repeated .tensorflow.GraphTransferConstNodeInfo const_node_info = 2;
2289 case 2:
2290 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2291 ptr -= 1;
2292 do {
2293 ptr += 1;
2294 ptr = ctx->ParseMessage(_internal_add_const_node_info(), ptr);
2295 CHK_(ptr);
2296 if (!ctx->DataAvailable(ptr)) break;
2297 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
2298 } else {
2299 goto handle_unusual;
2300 }
2301 continue;
2302 // repeated .tensorflow.GraphTransferNodeInputInfo node_input_info = 3;
2303 case 3:
2304 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2305 ptr -= 1;
2306 do {
2307 ptr += 1;
2308 ptr = ctx->ParseMessage(_internal_add_node_input_info(), ptr);
2309 CHK_(ptr);
2310 if (!ctx->DataAvailable(ptr)) break;
2311 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
2312 } else {
2313 goto handle_unusual;
2314 }
2315 continue;
2316 // repeated .tensorflow.GraphTransferNodeOutputInfo node_output_info = 4;
2317 case 4:
2318 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2319 ptr -= 1;
2320 do {
2321 ptr += 1;
2322 ptr = ctx->ParseMessage(_internal_add_node_output_info(), ptr);
2323 CHK_(ptr);
2324 if (!ctx->DataAvailable(ptr)) break;
2325 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
2326 } else {
2327 goto handle_unusual;
2328 }
2329 continue;
2330 // repeated .tensorflow.GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
2331 case 5:
2332 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2333 ptr -= 1;
2334 do {
2335 ptr += 1;
2336 ptr = ctx->ParseMessage(_internal_add_graph_input_node_info(), ptr);
2337 CHK_(ptr);
2338 if (!ctx->DataAvailable(ptr)) break;
2339 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
2340 } else {
2341 goto handle_unusual;
2342 }
2343 continue;
2344 // repeated .tensorflow.GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
2345 case 6:
2346 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
2347 ptr -= 1;
2348 do {
2349 ptr += 1;
2350 ptr = ctx->ParseMessage(_internal_add_graph_output_node_info(), ptr);
2351 CHK_(ptr);
2352 if (!ctx->DataAvailable(ptr)) break;
2353 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
2354 } else {
2355 goto handle_unusual;
2356 }
2357 continue;
2358 // .tensorflow.GraphTransferInfo.Destination destination = 7;
2359 case 7:
2360 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
2361 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2362 CHK_(ptr);
2363 _internal_set_destination(static_cast<::tensorflow::GraphTransferInfo_Destination>(val));
2364 } else {
2365 goto handle_unusual;
2366 }
2367 continue;
2368 default:
2369 goto handle_unusual;
2370 } // switch
2371 handle_unusual:
2372 if ((tag == 0) || ((tag & 7) == 4)) {
2373 CHK_(ptr);
2374 ctx->SetLastTag(tag);
2375 goto message_done;
2376 }
2377 ptr = UnknownFieldParse(
2378 tag,
2379 _internal_metadata_.mutable_unknown_fields<std::string>(),
2380 ptr, ctx);
2381 CHK_(ptr != nullptr);
2382 } // while
2383 message_done:
2384 return ptr;
2385 failure:
2386 ptr = nullptr;
2387 goto message_done;
2388 #undef CHK_
2389 }
2390
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2391 ::uint8_t* GraphTransferInfo::_InternalSerialize(
2392 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2393 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.GraphTransferInfo)
2394 ::uint32_t cached_has_bits = 0;
2395 (void) cached_has_bits;
2396
2397 // repeated .tensorflow.GraphTransferNodeInfo node_info = 1;
2398 for (unsigned i = 0,
2399 n = static_cast<unsigned>(this->_internal_node_info_size()); i < n; i++) {
2400 const auto& repfield = this->_internal_node_info(i);
2401 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2402 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
2403 }
2404
2405 // repeated .tensorflow.GraphTransferConstNodeInfo const_node_info = 2;
2406 for (unsigned i = 0,
2407 n = static_cast<unsigned>(this->_internal_const_node_info_size()); i < n; i++) {
2408 const auto& repfield = this->_internal_const_node_info(i);
2409 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2410 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
2411 }
2412
2413 // repeated .tensorflow.GraphTransferNodeInputInfo node_input_info = 3;
2414 for (unsigned i = 0,
2415 n = static_cast<unsigned>(this->_internal_node_input_info_size()); i < n; i++) {
2416 const auto& repfield = this->_internal_node_input_info(i);
2417 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2418 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
2419 }
2420
2421 // repeated .tensorflow.GraphTransferNodeOutputInfo node_output_info = 4;
2422 for (unsigned i = 0,
2423 n = static_cast<unsigned>(this->_internal_node_output_info_size()); i < n; i++) {
2424 const auto& repfield = this->_internal_node_output_info(i);
2425 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2426 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
2427 }
2428
2429 // repeated .tensorflow.GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
2430 for (unsigned i = 0,
2431 n = static_cast<unsigned>(this->_internal_graph_input_node_info_size()); i < n; i++) {
2432 const auto& repfield = this->_internal_graph_input_node_info(i);
2433 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2434 InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
2435 }
2436
2437 // repeated .tensorflow.GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
2438 for (unsigned i = 0,
2439 n = static_cast<unsigned>(this->_internal_graph_output_node_info_size()); i < n; i++) {
2440 const auto& repfield = this->_internal_graph_output_node_info(i);
2441 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2442 InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
2443 }
2444
2445 // .tensorflow.GraphTransferInfo.Destination destination = 7;
2446 if (this->_internal_destination() != 0) {
2447 target = stream->EnsureSpace(target);
2448 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2449 7, this->_internal_destination(), target);
2450 }
2451
2452 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2453 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2454 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2455 }
2456 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.GraphTransferInfo)
2457 return target;
2458 }
2459
ByteSizeLong() const2460 size_t GraphTransferInfo::ByteSizeLong() const {
2461 // @@protoc_insertion_point(message_byte_size_start:tensorflow.GraphTransferInfo)
2462 size_t total_size = 0;
2463
2464 ::uint32_t cached_has_bits = 0;
2465 // Prevent compiler warnings about cached_has_bits being unused
2466 (void) cached_has_bits;
2467
2468 // repeated .tensorflow.GraphTransferNodeInfo node_info = 1;
2469 total_size += 1UL * this->_internal_node_info_size();
2470 for (const auto& msg : this->_impl_.node_info_) {
2471 total_size +=
2472 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2473 }
2474
2475 // repeated .tensorflow.GraphTransferConstNodeInfo const_node_info = 2;
2476 total_size += 1UL * this->_internal_const_node_info_size();
2477 for (const auto& msg : this->_impl_.const_node_info_) {
2478 total_size +=
2479 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2480 }
2481
2482 // repeated .tensorflow.GraphTransferNodeInputInfo node_input_info = 3;
2483 total_size += 1UL * this->_internal_node_input_info_size();
2484 for (const auto& msg : this->_impl_.node_input_info_) {
2485 total_size +=
2486 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2487 }
2488
2489 // repeated .tensorflow.GraphTransferNodeOutputInfo node_output_info = 4;
2490 total_size += 1UL * this->_internal_node_output_info_size();
2491 for (const auto& msg : this->_impl_.node_output_info_) {
2492 total_size +=
2493 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2494 }
2495
2496 // repeated .tensorflow.GraphTransferGraphInputNodeInfo graph_input_node_info = 5;
2497 total_size += 1UL * this->_internal_graph_input_node_info_size();
2498 for (const auto& msg : this->_impl_.graph_input_node_info_) {
2499 total_size +=
2500 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2501 }
2502
2503 // repeated .tensorflow.GraphTransferGraphOutputNodeInfo graph_output_node_info = 6;
2504 total_size += 1UL * this->_internal_graph_output_node_info_size();
2505 for (const auto& msg : this->_impl_.graph_output_node_info_) {
2506 total_size +=
2507 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2508 }
2509
2510 // .tensorflow.GraphTransferInfo.Destination destination = 7;
2511 if (this->_internal_destination() != 0) {
2512 total_size += 1 +
2513 ::_pbi::WireFormatLite::EnumSize(this->_internal_destination());
2514 }
2515
2516 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2517 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2518 }
2519 int cached_size = ::_pbi::ToCachedSize(total_size);
2520 SetCachedSize(cached_size);
2521 return total_size;
2522 }
2523
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2524 void GraphTransferInfo::CheckTypeAndMergeFrom(
2525 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2526 MergeFrom(*::_pbi::DownCast<const GraphTransferInfo*>(
2527 &from));
2528 }
2529
MergeFrom(const GraphTransferInfo & from)2530 void GraphTransferInfo::MergeFrom(const GraphTransferInfo& from) {
2531 GraphTransferInfo* const _this = this;
2532 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.GraphTransferInfo)
2533 GOOGLE_DCHECK_NE(&from, _this);
2534 ::uint32_t cached_has_bits = 0;
2535 (void) cached_has_bits;
2536
2537 _this->_impl_.node_info_.MergeFrom(from._impl_.node_info_);
2538 _this->_impl_.const_node_info_.MergeFrom(from._impl_.const_node_info_);
2539 _this->_impl_.node_input_info_.MergeFrom(from._impl_.node_input_info_);
2540 _this->_impl_.node_output_info_.MergeFrom(from._impl_.node_output_info_);
2541 _this->_impl_.graph_input_node_info_.MergeFrom(from._impl_.graph_input_node_info_);
2542 _this->_impl_.graph_output_node_info_.MergeFrom(from._impl_.graph_output_node_info_);
2543 if (from._internal_destination() != 0) {
2544 _this->_internal_set_destination(from._internal_destination());
2545 }
2546 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2547 }
2548
CopyFrom(const GraphTransferInfo & from)2549 void GraphTransferInfo::CopyFrom(const GraphTransferInfo& from) {
2550 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.GraphTransferInfo)
2551 if (&from == this) return;
2552 Clear();
2553 MergeFrom(from);
2554 }
2555
IsInitialized() const2556 bool GraphTransferInfo::IsInitialized() const {
2557 return true;
2558 }
2559
InternalSwap(GraphTransferInfo * other)2560 void GraphTransferInfo::InternalSwap(GraphTransferInfo* other) {
2561 using std::swap;
2562 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2563 _impl_.node_info_.InternalSwap(&other->_impl_.node_info_);
2564 _impl_.const_node_info_.InternalSwap(&other->_impl_.const_node_info_);
2565 _impl_.node_input_info_.InternalSwap(&other->_impl_.node_input_info_);
2566 _impl_.node_output_info_.InternalSwap(&other->_impl_.node_output_info_);
2567 _impl_.graph_input_node_info_.InternalSwap(&other->_impl_.graph_input_node_info_);
2568 _impl_.graph_output_node_info_.InternalSwap(&other->_impl_.graph_output_node_info_);
2569 swap(_impl_.destination_, other->_impl_.destination_);
2570 }
2571
GetTypeName() const2572 std::string GraphTransferInfo::GetTypeName() const {
2573 return "tensorflow.GraphTransferInfo";
2574 }
2575
2576
2577 // @@protoc_insertion_point(namespace_scope)
2578 } // namespace tensorflow
2579 PROTOBUF_NAMESPACE_OPEN
2580 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferNodeInput*
CreateMaybeMessage(Arena * arena)2581 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferNodeInput >(Arena* arena) {
2582 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferNodeInput >(arena);
2583 }
2584 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferNodeInfo*
CreateMaybeMessage(Arena * arena)2585 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferNodeInfo >(Arena* arena) {
2586 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferNodeInfo >(arena);
2587 }
2588 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferConstNodeInfo*
CreateMaybeMessage(Arena * arena)2589 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferConstNodeInfo >(Arena* arena) {
2590 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferConstNodeInfo >(arena);
2591 }
2592 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferNodeInputInfo*
CreateMaybeMessage(Arena * arena)2593 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferNodeInputInfo >(Arena* arena) {
2594 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferNodeInputInfo >(arena);
2595 }
2596 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferNodeOutputInfo*
CreateMaybeMessage(Arena * arena)2597 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferNodeOutputInfo >(Arena* arena) {
2598 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferNodeOutputInfo >(arena);
2599 }
2600 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferGraphInputNodeInfo*
CreateMaybeMessage(Arena * arena)2601 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferGraphInputNodeInfo >(Arena* arena) {
2602 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferGraphInputNodeInfo >(arena);
2603 }
2604 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferGraphOutputNodeInfo*
CreateMaybeMessage(Arena * arena)2605 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferGraphOutputNodeInfo >(Arena* arena) {
2606 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferGraphOutputNodeInfo >(arena);
2607 }
2608 template<> PROTOBUF_NOINLINE ::tensorflow::GraphTransferInfo*
CreateMaybeMessage(Arena * arena)2609 Arena::CreateMaybeMessage< ::tensorflow::GraphTransferInfo >(Arena* arena) {
2610 return Arena::CreateMessageInternal< ::tensorflow::GraphTransferInfo >(arena);
2611 }
2612 PROTOBUF_NAMESPACE_CLOSE
2613
2614 // @@protoc_insertion_point(global_scope)
2615 #include <google/protobuf/port_undef.inc>
2616