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