1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/tensorflow_server.proto
3
4 #include "tensorflow/core/protobuf/tensorflow_server.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 {
ServerDef(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR ServerDef::ServerDef(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.job_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
25 , /*decltype(_impl_.protocol_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
26 , /*decltype(_impl_.cluster_)*/nullptr
27 , /*decltype(_impl_.default_session_config_)*/nullptr
28 , /*decltype(_impl_.cluster_device_filters_)*/nullptr
29 , /*decltype(_impl_.task_index_)*/0
30 , /*decltype(_impl_.port_)*/0
31 , /*decltype(_impl_._cached_size_)*/{}} {}
32 struct ServerDefDefaultTypeInternal {
ServerDefDefaultTypeInternaltensorflow::ServerDefDefaultTypeInternal33 PROTOBUF_CONSTEXPR ServerDefDefaultTypeInternal()
34 : _instance(::_pbi::ConstantInitialized{}) {}
~ServerDefDefaultTypeInternaltensorflow::ServerDefDefaultTypeInternal35 ~ServerDefDefaultTypeInternal() {}
36 union { // NOLINT(misc-non-private-member-variables-in-classes)
37 ServerDef _instance;
38 };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerDefDefaultTypeInternal _ServerDef_default_instance_;
41 } // namespace tensorflow
42 namespace tensorflow {
43
44 // ===================================================================
45
46 class ServerDef::_Internal {
47 public:
48 static const ::tensorflow::ClusterDef& cluster(const ServerDef* msg);
49 static const ::tensorflow::ConfigProto& default_session_config(const ServerDef* msg);
50 static const ::tensorflow::ClusterDeviceFilters& cluster_device_filters(const ServerDef* msg);
51 };
52
53 const ::tensorflow::ClusterDef&
cluster(const ServerDef * msg)54 ServerDef::_Internal::cluster(const ServerDef* msg) {
55 return *msg->_impl_.cluster_;
56 }
57 const ::tensorflow::ConfigProto&
default_session_config(const ServerDef * msg)58 ServerDef::_Internal::default_session_config(const ServerDef* msg) {
59 return *msg->_impl_.default_session_config_;
60 }
61 const ::tensorflow::ClusterDeviceFilters&
cluster_device_filters(const ServerDef * msg)62 ServerDef::_Internal::cluster_device_filters(const ServerDef* msg) {
63 return *msg->_impl_.cluster_device_filters_;
64 }
clear_cluster()65 void ServerDef::clear_cluster() {
66 if (GetArenaForAllocation() == nullptr && _impl_.cluster_ != nullptr) {
67 delete _impl_.cluster_;
68 }
69 _impl_.cluster_ = nullptr;
70 }
clear_default_session_config()71 void ServerDef::clear_default_session_config() {
72 if (GetArenaForAllocation() == nullptr && _impl_.default_session_config_ != nullptr) {
73 delete _impl_.default_session_config_;
74 }
75 _impl_.default_session_config_ = nullptr;
76 }
clear_cluster_device_filters()77 void ServerDef::clear_cluster_device_filters() {
78 if (GetArenaForAllocation() == nullptr && _impl_.cluster_device_filters_ != nullptr) {
79 delete _impl_.cluster_device_filters_;
80 }
81 _impl_.cluster_device_filters_ = nullptr;
82 }
ServerDef(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)83 ServerDef::ServerDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
84 bool is_message_owned)
85 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
86 SharedCtor(arena, is_message_owned);
87 // @@protoc_insertion_point(arena_constructor:tensorflow.ServerDef)
88 }
ServerDef(const ServerDef & from)89 ServerDef::ServerDef(const ServerDef& from)
90 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
91 ServerDef* const _this = this; (void)_this;
92 new (&_impl_) Impl_{
93 decltype(_impl_.job_name_){}
94 , decltype(_impl_.protocol_){}
95 , decltype(_impl_.cluster_){nullptr}
96 , decltype(_impl_.default_session_config_){nullptr}
97 , decltype(_impl_.cluster_device_filters_){nullptr}
98 , decltype(_impl_.task_index_){}
99 , decltype(_impl_.port_){}
100 , /*decltype(_impl_._cached_size_)*/{}};
101
102 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
103 _impl_.job_name_.InitDefault();
104 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
105 _impl_.job_name_.Set("", GetArenaForAllocation());
106 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
107 if (!from._internal_job_name().empty()) {
108 _this->_impl_.job_name_.Set(from._internal_job_name(),
109 _this->GetArenaForAllocation());
110 }
111 _impl_.protocol_.InitDefault();
112 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
113 _impl_.protocol_.Set("", GetArenaForAllocation());
114 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
115 if (!from._internal_protocol().empty()) {
116 _this->_impl_.protocol_.Set(from._internal_protocol(),
117 _this->GetArenaForAllocation());
118 }
119 if (from._internal_has_cluster()) {
120 _this->_impl_.cluster_ = new ::tensorflow::ClusterDef(*from._impl_.cluster_);
121 }
122 if (from._internal_has_default_session_config()) {
123 _this->_impl_.default_session_config_ = new ::tensorflow::ConfigProto(*from._impl_.default_session_config_);
124 }
125 if (from._internal_has_cluster_device_filters()) {
126 _this->_impl_.cluster_device_filters_ = new ::tensorflow::ClusterDeviceFilters(*from._impl_.cluster_device_filters_);
127 }
128 ::memcpy(&_impl_.task_index_, &from._impl_.task_index_,
129 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.port_) -
130 reinterpret_cast<char*>(&_impl_.task_index_)) + sizeof(_impl_.port_));
131 // @@protoc_insertion_point(copy_constructor:tensorflow.ServerDef)
132 }
133
SharedCtor(::_pb::Arena * arena,bool is_message_owned)134 inline void ServerDef::SharedCtor(
135 ::_pb::Arena* arena, bool is_message_owned) {
136 (void)arena;
137 (void)is_message_owned;
138 new (&_impl_) Impl_{
139 decltype(_impl_.job_name_){}
140 , decltype(_impl_.protocol_){}
141 , decltype(_impl_.cluster_){nullptr}
142 , decltype(_impl_.default_session_config_){nullptr}
143 , decltype(_impl_.cluster_device_filters_){nullptr}
144 , decltype(_impl_.task_index_){0}
145 , decltype(_impl_.port_){0}
146 , /*decltype(_impl_._cached_size_)*/{}
147 };
148 _impl_.job_name_.InitDefault();
149 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
150 _impl_.job_name_.Set("", GetArenaForAllocation());
151 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
152 _impl_.protocol_.InitDefault();
153 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
154 _impl_.protocol_.Set("", GetArenaForAllocation());
155 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
156 }
157
~ServerDef()158 ServerDef::~ServerDef() {
159 // @@protoc_insertion_point(destructor:tensorflow.ServerDef)
160 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
161 (void)arena;
162 return;
163 }
164 SharedDtor();
165 }
166
SharedDtor()167 inline void ServerDef::SharedDtor() {
168 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
169 _impl_.job_name_.Destroy();
170 _impl_.protocol_.Destroy();
171 if (this != internal_default_instance()) delete _impl_.cluster_;
172 if (this != internal_default_instance()) delete _impl_.default_session_config_;
173 if (this != internal_default_instance()) delete _impl_.cluster_device_filters_;
174 }
175
SetCachedSize(int size) const176 void ServerDef::SetCachedSize(int size) const {
177 _impl_._cached_size_.Set(size);
178 }
179
Clear()180 void ServerDef::Clear() {
181 // @@protoc_insertion_point(message_clear_start:tensorflow.ServerDef)
182 ::uint32_t cached_has_bits = 0;
183 // Prevent compiler warnings about cached_has_bits being unused
184 (void) cached_has_bits;
185
186 _impl_.job_name_.ClearToEmpty();
187 _impl_.protocol_.ClearToEmpty();
188 if (GetArenaForAllocation() == nullptr && _impl_.cluster_ != nullptr) {
189 delete _impl_.cluster_;
190 }
191 _impl_.cluster_ = nullptr;
192 if (GetArenaForAllocation() == nullptr && _impl_.default_session_config_ != nullptr) {
193 delete _impl_.default_session_config_;
194 }
195 _impl_.default_session_config_ = nullptr;
196 if (GetArenaForAllocation() == nullptr && _impl_.cluster_device_filters_ != nullptr) {
197 delete _impl_.cluster_device_filters_;
198 }
199 _impl_.cluster_device_filters_ = nullptr;
200 ::memset(&_impl_.task_index_, 0, static_cast<size_t>(
201 reinterpret_cast<char*>(&_impl_.port_) -
202 reinterpret_cast<char*>(&_impl_.task_index_)) + sizeof(_impl_.port_));
203 _internal_metadata_.Clear<std::string>();
204 }
205
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)206 const char* ServerDef::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
207 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
208 while (!ctx->Done(&ptr)) {
209 ::uint32_t tag;
210 ptr = ::_pbi::ReadTag(ptr, &tag);
211 switch (tag >> 3) {
212 // .tensorflow.ClusterDef cluster = 1;
213 case 1:
214 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
215 ptr = ctx->ParseMessage(_internal_mutable_cluster(), ptr);
216 CHK_(ptr);
217 } else {
218 goto handle_unusual;
219 }
220 continue;
221 // string job_name = 2;
222 case 2:
223 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
224 auto str = _internal_mutable_job_name();
225 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
226 CHK_(ptr);
227 CHK_(::_pbi::VerifyUTF8(str, nullptr));
228 } else {
229 goto handle_unusual;
230 }
231 continue;
232 // int32 task_index = 3;
233 case 3:
234 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
235 _impl_.task_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
236 CHK_(ptr);
237 } else {
238 goto handle_unusual;
239 }
240 continue;
241 // .tensorflow.ConfigProto default_session_config = 4;
242 case 4:
243 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
244 ptr = ctx->ParseMessage(_internal_mutable_default_session_config(), ptr);
245 CHK_(ptr);
246 } else {
247 goto handle_unusual;
248 }
249 continue;
250 // string protocol = 5;
251 case 5:
252 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
253 auto str = _internal_mutable_protocol();
254 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
255 CHK_(ptr);
256 CHK_(::_pbi::VerifyUTF8(str, nullptr));
257 } else {
258 goto handle_unusual;
259 }
260 continue;
261 // int32 port = 6;
262 case 6:
263 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
264 _impl_.port_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
265 CHK_(ptr);
266 } else {
267 goto handle_unusual;
268 }
269 continue;
270 // .tensorflow.ClusterDeviceFilters cluster_device_filters = 7;
271 case 7:
272 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
273 ptr = ctx->ParseMessage(_internal_mutable_cluster_device_filters(), ptr);
274 CHK_(ptr);
275 } else {
276 goto handle_unusual;
277 }
278 continue;
279 default:
280 goto handle_unusual;
281 } // switch
282 handle_unusual:
283 if ((tag == 0) || ((tag & 7) == 4)) {
284 CHK_(ptr);
285 ctx->SetLastTag(tag);
286 goto message_done;
287 }
288 ptr = UnknownFieldParse(
289 tag,
290 _internal_metadata_.mutable_unknown_fields<std::string>(),
291 ptr, ctx);
292 CHK_(ptr != nullptr);
293 } // while
294 message_done:
295 return ptr;
296 failure:
297 ptr = nullptr;
298 goto message_done;
299 #undef CHK_
300 }
301
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const302 ::uint8_t* ServerDef::_InternalSerialize(
303 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
304 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.ServerDef)
305 ::uint32_t cached_has_bits = 0;
306 (void) cached_has_bits;
307
308 // .tensorflow.ClusterDef cluster = 1;
309 if (this->_internal_has_cluster()) {
310 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
311 InternalWriteMessage(1, _Internal::cluster(this),
312 _Internal::cluster(this).GetCachedSize(), target, stream);
313 }
314
315 // string job_name = 2;
316 if (!this->_internal_job_name().empty()) {
317 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
318 this->_internal_job_name().data(), static_cast<int>(this->_internal_job_name().length()),
319 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
320 "tensorflow.ServerDef.job_name");
321 target = stream->WriteStringMaybeAliased(
322 2, this->_internal_job_name(), target);
323 }
324
325 // int32 task_index = 3;
326 if (this->_internal_task_index() != 0) {
327 target = stream->EnsureSpace(target);
328 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_task_index(), target);
329 }
330
331 // .tensorflow.ConfigProto default_session_config = 4;
332 if (this->_internal_has_default_session_config()) {
333 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
334 InternalWriteMessage(4, _Internal::default_session_config(this),
335 _Internal::default_session_config(this).GetCachedSize(), target, stream);
336 }
337
338 // string protocol = 5;
339 if (!this->_internal_protocol().empty()) {
340 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
341 this->_internal_protocol().data(), static_cast<int>(this->_internal_protocol().length()),
342 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
343 "tensorflow.ServerDef.protocol");
344 target = stream->WriteStringMaybeAliased(
345 5, this->_internal_protocol(), target);
346 }
347
348 // int32 port = 6;
349 if (this->_internal_port() != 0) {
350 target = stream->EnsureSpace(target);
351 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_port(), target);
352 }
353
354 // .tensorflow.ClusterDeviceFilters cluster_device_filters = 7;
355 if (this->_internal_has_cluster_device_filters()) {
356 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
357 InternalWriteMessage(7, _Internal::cluster_device_filters(this),
358 _Internal::cluster_device_filters(this).GetCachedSize(), target, stream);
359 }
360
361 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
362 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
363 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
364 }
365 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.ServerDef)
366 return target;
367 }
368
ByteSizeLong() const369 size_t ServerDef::ByteSizeLong() const {
370 // @@protoc_insertion_point(message_byte_size_start:tensorflow.ServerDef)
371 size_t total_size = 0;
372
373 ::uint32_t cached_has_bits = 0;
374 // Prevent compiler warnings about cached_has_bits being unused
375 (void) cached_has_bits;
376
377 // string job_name = 2;
378 if (!this->_internal_job_name().empty()) {
379 total_size += 1 +
380 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
381 this->_internal_job_name());
382 }
383
384 // string protocol = 5;
385 if (!this->_internal_protocol().empty()) {
386 total_size += 1 +
387 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
388 this->_internal_protocol());
389 }
390
391 // .tensorflow.ClusterDef cluster = 1;
392 if (this->_internal_has_cluster()) {
393 total_size += 1 +
394 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
395 *_impl_.cluster_);
396 }
397
398 // .tensorflow.ConfigProto default_session_config = 4;
399 if (this->_internal_has_default_session_config()) {
400 total_size += 1 +
401 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
402 *_impl_.default_session_config_);
403 }
404
405 // .tensorflow.ClusterDeviceFilters cluster_device_filters = 7;
406 if (this->_internal_has_cluster_device_filters()) {
407 total_size += 1 +
408 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
409 *_impl_.cluster_device_filters_);
410 }
411
412 // int32 task_index = 3;
413 if (this->_internal_task_index() != 0) {
414 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_task_index());
415 }
416
417 // int32 port = 6;
418 if (this->_internal_port() != 0) {
419 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_port());
420 }
421
422 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
423 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
424 }
425 int cached_size = ::_pbi::ToCachedSize(total_size);
426 SetCachedSize(cached_size);
427 return total_size;
428 }
429
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)430 void ServerDef::CheckTypeAndMergeFrom(
431 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
432 MergeFrom(*::_pbi::DownCast<const ServerDef*>(
433 &from));
434 }
435
MergeFrom(const ServerDef & from)436 void ServerDef::MergeFrom(const ServerDef& from) {
437 ServerDef* const _this = this;
438 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.ServerDef)
439 GOOGLE_DCHECK_NE(&from, _this);
440 ::uint32_t cached_has_bits = 0;
441 (void) cached_has_bits;
442
443 if (!from._internal_job_name().empty()) {
444 _this->_internal_set_job_name(from._internal_job_name());
445 }
446 if (!from._internal_protocol().empty()) {
447 _this->_internal_set_protocol(from._internal_protocol());
448 }
449 if (from._internal_has_cluster()) {
450 _this->_internal_mutable_cluster()->::tensorflow::ClusterDef::MergeFrom(
451 from._internal_cluster());
452 }
453 if (from._internal_has_default_session_config()) {
454 _this->_internal_mutable_default_session_config()->::tensorflow::ConfigProto::MergeFrom(
455 from._internal_default_session_config());
456 }
457 if (from._internal_has_cluster_device_filters()) {
458 _this->_internal_mutable_cluster_device_filters()->::tensorflow::ClusterDeviceFilters::MergeFrom(
459 from._internal_cluster_device_filters());
460 }
461 if (from._internal_task_index() != 0) {
462 _this->_internal_set_task_index(from._internal_task_index());
463 }
464 if (from._internal_port() != 0) {
465 _this->_internal_set_port(from._internal_port());
466 }
467 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
468 }
469
CopyFrom(const ServerDef & from)470 void ServerDef::CopyFrom(const ServerDef& from) {
471 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.ServerDef)
472 if (&from == this) return;
473 Clear();
474 MergeFrom(from);
475 }
476
IsInitialized() const477 bool ServerDef::IsInitialized() const {
478 return true;
479 }
480
InternalSwap(ServerDef * other)481 void ServerDef::InternalSwap(ServerDef* other) {
482 using std::swap;
483 auto* lhs_arena = GetArenaForAllocation();
484 auto* rhs_arena = other->GetArenaForAllocation();
485 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
486 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
487 &_impl_.job_name_, lhs_arena,
488 &other->_impl_.job_name_, rhs_arena
489 );
490 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
491 &_impl_.protocol_, lhs_arena,
492 &other->_impl_.protocol_, rhs_arena
493 );
494 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
495 PROTOBUF_FIELD_OFFSET(ServerDef, _impl_.port_)
496 + sizeof(ServerDef::_impl_.port_) // NOLINT
497 - PROTOBUF_FIELD_OFFSET(ServerDef, _impl_.cluster_)>(
498 reinterpret_cast<char*>(&_impl_.cluster_),
499 reinterpret_cast<char*>(&other->_impl_.cluster_));
500 }
501
GetTypeName() const502 std::string ServerDef::GetTypeName() const {
503 return "tensorflow.ServerDef";
504 }
505
506
507 // @@protoc_insertion_point(namespace_scope)
508 } // namespace tensorflow
509 PROTOBUF_NAMESPACE_OPEN
510 template<> PROTOBUF_NOINLINE ::tensorflow::ServerDef*
CreateMaybeMessage(Arena * arena)511 Arena::CreateMaybeMessage< ::tensorflow::ServerDef >(Arena* arena) {
512 return Arena::CreateMessageInternal< ::tensorflow::ServerDef >(arena);
513 }
514 PROTOBUF_NAMESPACE_CLOSE
515
516 // @@protoc_insertion_point(global_scope)
517 #include <google/protobuf/port_undef.inc>
518