1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/saved_object_graph.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include <google/protobuf/generated_enum_util.h>
36 #include <google/protobuf/any.pb.h>
37 #include "tensorflow/core/framework/tensor_shape.pb.h"
38 #include "tensorflow/core/framework/types.pb.h"
39 #include "tensorflow/core/framework/variable.pb.h"
40 #include "tensorflow/core/framework/versions.pb.h"
41 #include "tensorflow/core/protobuf/struct.pb.h"
42 #include "tensorflow/core/protobuf/trackable_object_graph.pb.h"
43 // @@protoc_insertion_point(includes)
44 #include <google/protobuf/port_def.inc>
45 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto
46 PROTOBUF_NAMESPACE_OPEN
47 namespace internal {
48 class AnyMetadata;
49 } // namespace internal
50 PROTOBUF_NAMESPACE_CLOSE
51
52 // Internal implementation detail -- do not use these members.
53 struct TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto {
54 static const ::uint32_t offsets[];
55 };
56 namespace tensorflow {
57 class CapturedTensor;
58 struct CapturedTensorDefaultTypeInternal;
59 extern CapturedTensorDefaultTypeInternal _CapturedTensor_default_instance_;
60 class FunctionSpec;
61 struct FunctionSpecDefaultTypeInternal;
62 extern FunctionSpecDefaultTypeInternal _FunctionSpec_default_instance_;
63 class SaveableObject;
64 struct SaveableObjectDefaultTypeInternal;
65 extern SaveableObjectDefaultTypeInternal _SaveableObject_default_instance_;
66 class SavedAsset;
67 struct SavedAssetDefaultTypeInternal;
68 extern SavedAssetDefaultTypeInternal _SavedAsset_default_instance_;
69 class SavedBareConcreteFunction;
70 struct SavedBareConcreteFunctionDefaultTypeInternal;
71 extern SavedBareConcreteFunctionDefaultTypeInternal _SavedBareConcreteFunction_default_instance_;
72 class SavedConcreteFunction;
73 struct SavedConcreteFunctionDefaultTypeInternal;
74 extern SavedConcreteFunctionDefaultTypeInternal _SavedConcreteFunction_default_instance_;
75 class SavedConstant;
76 struct SavedConstantDefaultTypeInternal;
77 extern SavedConstantDefaultTypeInternal _SavedConstant_default_instance_;
78 class SavedFunction;
79 struct SavedFunctionDefaultTypeInternal;
80 extern SavedFunctionDefaultTypeInternal _SavedFunction_default_instance_;
81 class SavedObject;
82 struct SavedObjectDefaultTypeInternal;
83 extern SavedObjectDefaultTypeInternal _SavedObject_default_instance_;
84 class SavedObjectGraph;
85 struct SavedObjectGraphDefaultTypeInternal;
86 extern SavedObjectGraphDefaultTypeInternal _SavedObjectGraph_default_instance_;
87 class SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse;
88 struct SavedObjectGraph_ConcreteFunctionsEntry_DoNotUseDefaultTypeInternal;
89 extern SavedObjectGraph_ConcreteFunctionsEntry_DoNotUseDefaultTypeInternal _SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse_default_instance_;
90 class SavedObject_SaveableObjectsEntry_DoNotUse;
91 struct SavedObject_SaveableObjectsEntry_DoNotUseDefaultTypeInternal;
92 extern SavedObject_SaveableObjectsEntry_DoNotUseDefaultTypeInternal _SavedObject_SaveableObjectsEntry_DoNotUse_default_instance_;
93 class SavedResource;
94 struct SavedResourceDefaultTypeInternal;
95 extern SavedResourceDefaultTypeInternal _SavedResource_default_instance_;
96 class SavedUserObject;
97 struct SavedUserObjectDefaultTypeInternal;
98 extern SavedUserObjectDefaultTypeInternal _SavedUserObject_default_instance_;
99 class SavedVariable;
100 struct SavedVariableDefaultTypeInternal;
101 extern SavedVariableDefaultTypeInternal _SavedVariable_default_instance_;
102 } // namespace tensorflow
103 PROTOBUF_NAMESPACE_OPEN
104 template<> ::tensorflow::CapturedTensor* Arena::CreateMaybeMessage<::tensorflow::CapturedTensor>(Arena*);
105 template<> ::tensorflow::FunctionSpec* Arena::CreateMaybeMessage<::tensorflow::FunctionSpec>(Arena*);
106 template<> ::tensorflow::SaveableObject* Arena::CreateMaybeMessage<::tensorflow::SaveableObject>(Arena*);
107 template<> ::tensorflow::SavedAsset* Arena::CreateMaybeMessage<::tensorflow::SavedAsset>(Arena*);
108 template<> ::tensorflow::SavedBareConcreteFunction* Arena::CreateMaybeMessage<::tensorflow::SavedBareConcreteFunction>(Arena*);
109 template<> ::tensorflow::SavedConcreteFunction* Arena::CreateMaybeMessage<::tensorflow::SavedConcreteFunction>(Arena*);
110 template<> ::tensorflow::SavedConstant* Arena::CreateMaybeMessage<::tensorflow::SavedConstant>(Arena*);
111 template<> ::tensorflow::SavedFunction* Arena::CreateMaybeMessage<::tensorflow::SavedFunction>(Arena*);
112 template<> ::tensorflow::SavedObject* Arena::CreateMaybeMessage<::tensorflow::SavedObject>(Arena*);
113 template<> ::tensorflow::SavedObjectGraph* Arena::CreateMaybeMessage<::tensorflow::SavedObjectGraph>(Arena*);
114 template<> ::tensorflow::SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse>(Arena*);
115 template<> ::tensorflow::SavedObject_SaveableObjectsEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::SavedObject_SaveableObjectsEntry_DoNotUse>(Arena*);
116 template<> ::tensorflow::SavedResource* Arena::CreateMaybeMessage<::tensorflow::SavedResource>(Arena*);
117 template<> ::tensorflow::SavedUserObject* Arena::CreateMaybeMessage<::tensorflow::SavedUserObject>(Arena*);
118 template<> ::tensorflow::SavedVariable* Arena::CreateMaybeMessage<::tensorflow::SavedVariable>(Arena*);
119 PROTOBUF_NAMESPACE_CLOSE
120 namespace tensorflow {
121
122 enum FunctionSpec_JitCompile : int {
123 FunctionSpec_JitCompile_DEFAULT = 0,
124 FunctionSpec_JitCompile_ON = 1,
125 FunctionSpec_JitCompile_OFF = 2,
126 FunctionSpec_JitCompile_FunctionSpec_JitCompile_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
127 FunctionSpec_JitCompile_FunctionSpec_JitCompile_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
128 };
129 bool FunctionSpec_JitCompile_IsValid(int value);
130 constexpr FunctionSpec_JitCompile FunctionSpec_JitCompile_JitCompile_MIN = FunctionSpec_JitCompile_DEFAULT;
131 constexpr FunctionSpec_JitCompile FunctionSpec_JitCompile_JitCompile_MAX = FunctionSpec_JitCompile_OFF;
132 constexpr int FunctionSpec_JitCompile_JitCompile_ARRAYSIZE = FunctionSpec_JitCompile_JitCompile_MAX + 1;
133
134 const std::string& FunctionSpec_JitCompile_Name(FunctionSpec_JitCompile value);
135 template<typename T>
FunctionSpec_JitCompile_Name(T enum_t_value)136 inline const std::string& FunctionSpec_JitCompile_Name(T enum_t_value) {
137 static_assert(::std::is_same<T, FunctionSpec_JitCompile>::value ||
138 ::std::is_integral<T>::value,
139 "Incorrect type passed to function FunctionSpec_JitCompile_Name.");
140 return FunctionSpec_JitCompile_Name(static_cast<FunctionSpec_JitCompile>(enum_t_value));
141 }
142 bool FunctionSpec_JitCompile_Parse(
143 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSpec_JitCompile* value);
144 // ===================================================================
145
146 class SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse,
147 std::string, ::tensorflow::SavedConcreteFunction,
148 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
149 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
150 public:
151 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse,
152 std::string, ::tensorflow::SavedConcreteFunction,
153 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
154 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
155 SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse();
156 explicit PROTOBUF_CONSTEXPR SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse(
157 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
158 explicit SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
159 void MergeFrom(const SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse& other);
internal_default_instance()160 static const SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse*>(&_SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)161 static bool ValidateKey(std::string* s) {
162 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.SavedObjectGraph.ConcreteFunctionsEntry.key");
163 }
ValidateValue(void *)164 static bool ValidateValue(void*) { return true; }
165 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
166 };
167
168 // -------------------------------------------------------------------
169
170 class SavedObjectGraph final :
171 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedObjectGraph) */ {
172 public:
SavedObjectGraph()173 inline SavedObjectGraph() : SavedObjectGraph(nullptr) {}
174 ~SavedObjectGraph() override;
175 explicit PROTOBUF_CONSTEXPR SavedObjectGraph(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
176
177 SavedObjectGraph(const SavedObjectGraph& from);
SavedObjectGraph(SavedObjectGraph && from)178 SavedObjectGraph(SavedObjectGraph&& from) noexcept
179 : SavedObjectGraph() {
180 *this = ::std::move(from);
181 }
182
183 inline SavedObjectGraph& operator=(const SavedObjectGraph& from) {
184 if (this == &from) return *this;
185 CopyFrom(from);
186 return *this;
187 }
188 inline SavedObjectGraph& operator=(SavedObjectGraph&& from) noexcept {
189 if (this == &from) return *this;
190 if (GetOwningArena() == from.GetOwningArena()
191 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
192 && GetOwningArena() != nullptr
193 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
194 ) {
195 InternalSwap(&from);
196 } else {
197 CopyFrom(from);
198 }
199 return *this;
200 }
201
default_instance()202 static const SavedObjectGraph& default_instance() {
203 return *internal_default_instance();
204 }
internal_default_instance()205 static inline const SavedObjectGraph* internal_default_instance() {
206 return reinterpret_cast<const SavedObjectGraph*>(
207 &_SavedObjectGraph_default_instance_);
208 }
209 static constexpr int kIndexInFileMessages =
210 1;
211
swap(SavedObjectGraph & a,SavedObjectGraph & b)212 friend void swap(SavedObjectGraph& a, SavedObjectGraph& b) {
213 a.Swap(&b);
214 }
Swap(SavedObjectGraph * other)215 inline void Swap(SavedObjectGraph* other) {
216 if (other == this) return;
217 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
218 if (GetOwningArena() != nullptr &&
219 GetOwningArena() == other->GetOwningArena()) {
220 #else // PROTOBUF_FORCE_COPY_IN_SWAP
221 if (GetOwningArena() == other->GetOwningArena()) {
222 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
223 InternalSwap(other);
224 } else {
225 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
226 }
227 }
228 void UnsafeArenaSwap(SavedObjectGraph* other) {
229 if (other == this) return;
230 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
231 InternalSwap(other);
232 }
233
234 // implements Message ----------------------------------------------
235
236 SavedObjectGraph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
237 return CreateMaybeMessage<SavedObjectGraph>(arena);
238 }
239 SavedObjectGraph* New() const {
240 return New(nullptr);
241 }
242 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
243 void CopyFrom(const SavedObjectGraph& from);
244 void MergeFrom(const SavedObjectGraph& from);
245 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
246 bool IsInitialized() const final;
247
248 size_t ByteSizeLong() const final;
249 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
250 ::uint8_t* _InternalSerialize(
251 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
252 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
253
254 private:
255 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
256 void SharedDtor();
257 void SetCachedSize(int size) const;
258 void InternalSwap(SavedObjectGraph* other);
259
260 private:
261 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
262 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
263 return "tensorflow.SavedObjectGraph";
264 }
265 protected:
266 explicit SavedObjectGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena,
267 bool is_message_owned = false);
268 public:
269
270 std::string GetTypeName() const final;
271
272 // nested types ----------------------------------------------------
273
274
275 // accessors -------------------------------------------------------
276
277 enum : int {
278 kNodesFieldNumber = 1,
279 kConcreteFunctionsFieldNumber = 2,
280 };
281 // repeated .tensorflow.SavedObject nodes = 1;
282 int nodes_size() const;
283 private:
284 int _internal_nodes_size() const;
285 public:
286 void clear_nodes();
287 ::tensorflow::SavedObject* mutable_nodes(int index);
288 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedObject >*
289 mutable_nodes();
290 private:
291 const ::tensorflow::SavedObject& _internal_nodes(int index) const;
292 ::tensorflow::SavedObject* _internal_add_nodes();
293 public:
294 const ::tensorflow::SavedObject& nodes(int index) const;
295 ::tensorflow::SavedObject* add_nodes();
296 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedObject >&
297 nodes() const;
298
299 // map<string, .tensorflow.SavedConcreteFunction> concrete_functions = 2;
300 int concrete_functions_size() const;
301 private:
302 int _internal_concrete_functions_size() const;
303 public:
304 void clear_concrete_functions();
305 private:
306 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >&
307 _internal_concrete_functions() const;
308 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >*
309 _internal_mutable_concrete_functions();
310 public:
311 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >&
312 concrete_functions() const;
313 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >*
314 mutable_concrete_functions();
315
316 // @@protoc_insertion_point(class_scope:tensorflow.SavedObjectGraph)
317 private:
318 class _Internal;
319
320 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
321 typedef void InternalArenaConstructable_;
322 typedef void DestructorSkippable_;
323 struct Impl_ {
324 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedObject > nodes_;
325 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
326 SavedObjectGraph_ConcreteFunctionsEntry_DoNotUse,
327 std::string, ::tensorflow::SavedConcreteFunction,
328 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
329 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> concrete_functions_;
330 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
331 };
332 union { Impl_ _impl_; };
333 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
334 };
335 // -------------------------------------------------------------------
336
337 class SavedObject_SaveableObjectsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SavedObject_SaveableObjectsEntry_DoNotUse,
338 std::string, ::tensorflow::SaveableObject,
339 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
340 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
341 public:
342 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<SavedObject_SaveableObjectsEntry_DoNotUse,
343 std::string, ::tensorflow::SaveableObject,
344 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
345 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
346 SavedObject_SaveableObjectsEntry_DoNotUse();
347 explicit PROTOBUF_CONSTEXPR SavedObject_SaveableObjectsEntry_DoNotUse(
348 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
349 explicit SavedObject_SaveableObjectsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
350 void MergeFrom(const SavedObject_SaveableObjectsEntry_DoNotUse& other);
internal_default_instance()351 static const SavedObject_SaveableObjectsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const SavedObject_SaveableObjectsEntry_DoNotUse*>(&_SavedObject_SaveableObjectsEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)352 static bool ValidateKey(std::string* s) {
353 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.SavedObject.SaveableObjectsEntry.key");
354 }
ValidateValue(void *)355 static bool ValidateValue(void*) { return true; }
356 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
357 };
358
359 // -------------------------------------------------------------------
360
361 class SavedObject final :
362 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedObject) */ {
363 public:
SavedObject()364 inline SavedObject() : SavedObject(nullptr) {}
365 ~SavedObject() override;
366 explicit PROTOBUF_CONSTEXPR SavedObject(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
367
368 SavedObject(const SavedObject& from);
SavedObject(SavedObject && from)369 SavedObject(SavedObject&& from) noexcept
370 : SavedObject() {
371 *this = ::std::move(from);
372 }
373
374 inline SavedObject& operator=(const SavedObject& from) {
375 if (this == &from) return *this;
376 CopyFrom(from);
377 return *this;
378 }
379 inline SavedObject& operator=(SavedObject&& from) noexcept {
380 if (this == &from) return *this;
381 if (GetOwningArena() == from.GetOwningArena()
382 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
383 && GetOwningArena() != nullptr
384 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
385 ) {
386 InternalSwap(&from);
387 } else {
388 CopyFrom(from);
389 }
390 return *this;
391 }
392
default_instance()393 static const SavedObject& default_instance() {
394 return *internal_default_instance();
395 }
396 enum KindCase {
397 kUserObject = 4,
398 kAsset = 5,
399 kFunction = 6,
400 kVariable = 7,
401 kBareConcreteFunction = 8,
402 kConstant = 9,
403 kResource = 10,
404 kCapturedTensor = 12,
405 KIND_NOT_SET = 0,
406 };
407
internal_default_instance()408 static inline const SavedObject* internal_default_instance() {
409 return reinterpret_cast<const SavedObject*>(
410 &_SavedObject_default_instance_);
411 }
412 static constexpr int kIndexInFileMessages =
413 3;
414
swap(SavedObject & a,SavedObject & b)415 friend void swap(SavedObject& a, SavedObject& b) {
416 a.Swap(&b);
417 }
Swap(SavedObject * other)418 inline void Swap(SavedObject* other) {
419 if (other == this) return;
420 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
421 if (GetOwningArena() != nullptr &&
422 GetOwningArena() == other->GetOwningArena()) {
423 #else // PROTOBUF_FORCE_COPY_IN_SWAP
424 if (GetOwningArena() == other->GetOwningArena()) {
425 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
426 InternalSwap(other);
427 } else {
428 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
429 }
430 }
431 void UnsafeArenaSwap(SavedObject* other) {
432 if (other == this) return;
433 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
434 InternalSwap(other);
435 }
436
437 // implements Message ----------------------------------------------
438
439 SavedObject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
440 return CreateMaybeMessage<SavedObject>(arena);
441 }
442 SavedObject* New() const {
443 return New(nullptr);
444 }
445 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
446 void CopyFrom(const SavedObject& from);
447 void MergeFrom(const SavedObject& from);
448 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
449 bool IsInitialized() const final;
450
451 size_t ByteSizeLong() const final;
452 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
453 ::uint8_t* _InternalSerialize(
454 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
455 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
456
457 private:
458 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
459 void SharedDtor();
460 void SetCachedSize(int size) const;
461 void InternalSwap(SavedObject* other);
462
463 private:
464 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
465 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
466 return "tensorflow.SavedObject";
467 }
468 protected:
469 explicit SavedObject(::PROTOBUF_NAMESPACE_ID::Arena* arena,
470 bool is_message_owned = false);
471 public:
472
473 std::string GetTypeName() const final;
474
475 // nested types ----------------------------------------------------
476
477
478 // accessors -------------------------------------------------------
479
480 enum : int {
481 kChildrenFieldNumber = 1,
482 kSlotVariablesFieldNumber = 3,
483 kSaveableObjectsFieldNumber = 11,
484 kDependenciesFieldNumber = 15,
485 kRegisteredNameFieldNumber = 13,
486 kRegisteredSaverFieldNumber = 16,
487 kSerializedUserProtoFieldNumber = 14,
488 kUserObjectFieldNumber = 4,
489 kAssetFieldNumber = 5,
490 kFunctionFieldNumber = 6,
491 kVariableFieldNumber = 7,
492 kBareConcreteFunctionFieldNumber = 8,
493 kConstantFieldNumber = 9,
494 kResourceFieldNumber = 10,
495 kCapturedTensorFieldNumber = 12,
496 };
497 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
498 int children_size() const;
499 private:
500 int _internal_children_size() const;
501 public:
502 void clear_children();
503 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* mutable_children(int index);
504 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
505 mutable_children();
506 private:
507 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& _internal_children(int index) const;
508 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _internal_add_children();
509 public:
510 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& children(int index) const;
511 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* add_children();
512 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
513 children() const;
514
515 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
516 int slot_variables_size() const;
517 private:
518 int _internal_slot_variables_size() const;
519 public:
520 void clear_slot_variables();
521 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* mutable_slot_variables(int index);
522 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >*
523 mutable_slot_variables();
524 private:
525 const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& _internal_slot_variables(int index) const;
526 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* _internal_add_slot_variables();
527 public:
528 const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& slot_variables(int index) const;
529 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* add_slot_variables();
530 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >&
531 slot_variables() const;
532
533 // map<string, .tensorflow.SaveableObject> saveable_objects = 11;
534 int saveable_objects_size() const;
535 private:
536 int _internal_saveable_objects_size() const;
537 public:
538 void clear_saveable_objects();
539 private:
540 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >&
541 _internal_saveable_objects() const;
542 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >*
543 _internal_mutable_saveable_objects();
544 public:
545 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >&
546 saveable_objects() const;
547 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >*
548 mutable_saveable_objects();
549
550 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference dependencies = 15;
551 int dependencies_size() const;
552 private:
553 int _internal_dependencies_size() const;
554 public:
555 void clear_dependencies();
556 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* mutable_dependencies(int index);
557 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
558 mutable_dependencies();
559 private:
560 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& _internal_dependencies(int index) const;
561 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _internal_add_dependencies();
562 public:
563 const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& dependencies(int index) const;
564 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* add_dependencies();
565 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
566 dependencies() const;
567
568 // string registered_name = 13;
569 void clear_registered_name();
570 const std::string& registered_name() const;
571 template <typename ArgT0 = const std::string&, typename... ArgT>
572 void set_registered_name(ArgT0&& arg0, ArgT... args);
573 std::string* mutable_registered_name();
574 PROTOBUF_NODISCARD std::string* release_registered_name();
575 void set_allocated_registered_name(std::string* registered_name);
576 private:
577 const std::string& _internal_registered_name() const;
578 inline PROTOBUF_ALWAYS_INLINE void _internal_set_registered_name(const std::string& value);
579 std::string* _internal_mutable_registered_name();
580 public:
581
582 // string registered_saver = 16;
583 void clear_registered_saver();
584 const std::string& registered_saver() const;
585 template <typename ArgT0 = const std::string&, typename... ArgT>
586 void set_registered_saver(ArgT0&& arg0, ArgT... args);
587 std::string* mutable_registered_saver();
588 PROTOBUF_NODISCARD std::string* release_registered_saver();
589 void set_allocated_registered_saver(std::string* registered_saver);
590 private:
591 const std::string& _internal_registered_saver() const;
592 inline PROTOBUF_ALWAYS_INLINE void _internal_set_registered_saver(const std::string& value);
593 std::string* _internal_mutable_registered_saver();
594 public:
595
596 // .google.protobuf.Any serialized_user_proto = 14;
597 bool has_serialized_user_proto() const;
598 private:
599 bool _internal_has_serialized_user_proto() const;
600 public:
601 void clear_serialized_user_proto();
602 const ::PROTOBUF_NAMESPACE_ID::Any& serialized_user_proto() const;
603 PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_serialized_user_proto();
604 ::PROTOBUF_NAMESPACE_ID::Any* mutable_serialized_user_proto();
605 void set_allocated_serialized_user_proto(::PROTOBUF_NAMESPACE_ID::Any* serialized_user_proto);
606 private:
607 const ::PROTOBUF_NAMESPACE_ID::Any& _internal_serialized_user_proto() const;
608 ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_serialized_user_proto();
609 public:
610 void unsafe_arena_set_allocated_serialized_user_proto(
611 ::PROTOBUF_NAMESPACE_ID::Any* serialized_user_proto);
612 ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_serialized_user_proto();
613
614 // .tensorflow.SavedUserObject user_object = 4;
615 bool has_user_object() const;
616 private:
617 bool _internal_has_user_object() const;
618 public:
619 void clear_user_object();
620 const ::tensorflow::SavedUserObject& user_object() const;
621 PROTOBUF_NODISCARD ::tensorflow::SavedUserObject* release_user_object();
622 ::tensorflow::SavedUserObject* mutable_user_object();
623 void set_allocated_user_object(::tensorflow::SavedUserObject* user_object);
624 private:
625 const ::tensorflow::SavedUserObject& _internal_user_object() const;
626 ::tensorflow::SavedUserObject* _internal_mutable_user_object();
627 public:
628 void unsafe_arena_set_allocated_user_object(
629 ::tensorflow::SavedUserObject* user_object);
630 ::tensorflow::SavedUserObject* unsafe_arena_release_user_object();
631
632 // .tensorflow.SavedAsset asset = 5;
633 bool has_asset() const;
634 private:
635 bool _internal_has_asset() const;
636 public:
637 void clear_asset();
638 const ::tensorflow::SavedAsset& asset() const;
639 PROTOBUF_NODISCARD ::tensorflow::SavedAsset* release_asset();
640 ::tensorflow::SavedAsset* mutable_asset();
641 void set_allocated_asset(::tensorflow::SavedAsset* asset);
642 private:
643 const ::tensorflow::SavedAsset& _internal_asset() const;
644 ::tensorflow::SavedAsset* _internal_mutable_asset();
645 public:
646 void unsafe_arena_set_allocated_asset(
647 ::tensorflow::SavedAsset* asset);
648 ::tensorflow::SavedAsset* unsafe_arena_release_asset();
649
650 // .tensorflow.SavedFunction function = 6;
651 bool has_function() const;
652 private:
653 bool _internal_has_function() const;
654 public:
655 void clear_function();
656 const ::tensorflow::SavedFunction& function() const;
657 PROTOBUF_NODISCARD ::tensorflow::SavedFunction* release_function();
658 ::tensorflow::SavedFunction* mutable_function();
659 void set_allocated_function(::tensorflow::SavedFunction* function);
660 private:
661 const ::tensorflow::SavedFunction& _internal_function() const;
662 ::tensorflow::SavedFunction* _internal_mutable_function();
663 public:
664 void unsafe_arena_set_allocated_function(
665 ::tensorflow::SavedFunction* function);
666 ::tensorflow::SavedFunction* unsafe_arena_release_function();
667
668 // .tensorflow.SavedVariable variable = 7;
669 bool has_variable() const;
670 private:
671 bool _internal_has_variable() const;
672 public:
673 void clear_variable();
674 const ::tensorflow::SavedVariable& variable() const;
675 PROTOBUF_NODISCARD ::tensorflow::SavedVariable* release_variable();
676 ::tensorflow::SavedVariable* mutable_variable();
677 void set_allocated_variable(::tensorflow::SavedVariable* variable);
678 private:
679 const ::tensorflow::SavedVariable& _internal_variable() const;
680 ::tensorflow::SavedVariable* _internal_mutable_variable();
681 public:
682 void unsafe_arena_set_allocated_variable(
683 ::tensorflow::SavedVariable* variable);
684 ::tensorflow::SavedVariable* unsafe_arena_release_variable();
685
686 // .tensorflow.SavedBareConcreteFunction bare_concrete_function = 8;
687 bool has_bare_concrete_function() const;
688 private:
689 bool _internal_has_bare_concrete_function() const;
690 public:
691 void clear_bare_concrete_function();
692 const ::tensorflow::SavedBareConcreteFunction& bare_concrete_function() const;
693 PROTOBUF_NODISCARD ::tensorflow::SavedBareConcreteFunction* release_bare_concrete_function();
694 ::tensorflow::SavedBareConcreteFunction* mutable_bare_concrete_function();
695 void set_allocated_bare_concrete_function(::tensorflow::SavedBareConcreteFunction* bare_concrete_function);
696 private:
697 const ::tensorflow::SavedBareConcreteFunction& _internal_bare_concrete_function() const;
698 ::tensorflow::SavedBareConcreteFunction* _internal_mutable_bare_concrete_function();
699 public:
700 void unsafe_arena_set_allocated_bare_concrete_function(
701 ::tensorflow::SavedBareConcreteFunction* bare_concrete_function);
702 ::tensorflow::SavedBareConcreteFunction* unsafe_arena_release_bare_concrete_function();
703
704 // .tensorflow.SavedConstant constant = 9;
705 bool has_constant() const;
706 private:
707 bool _internal_has_constant() const;
708 public:
709 void clear_constant();
710 const ::tensorflow::SavedConstant& constant() const;
711 PROTOBUF_NODISCARD ::tensorflow::SavedConstant* release_constant();
712 ::tensorflow::SavedConstant* mutable_constant();
713 void set_allocated_constant(::tensorflow::SavedConstant* constant);
714 private:
715 const ::tensorflow::SavedConstant& _internal_constant() const;
716 ::tensorflow::SavedConstant* _internal_mutable_constant();
717 public:
718 void unsafe_arena_set_allocated_constant(
719 ::tensorflow::SavedConstant* constant);
720 ::tensorflow::SavedConstant* unsafe_arena_release_constant();
721
722 // .tensorflow.SavedResource resource = 10;
723 bool has_resource() const;
724 private:
725 bool _internal_has_resource() const;
726 public:
727 void clear_resource();
728 const ::tensorflow::SavedResource& resource() const;
729 PROTOBUF_NODISCARD ::tensorflow::SavedResource* release_resource();
730 ::tensorflow::SavedResource* mutable_resource();
731 void set_allocated_resource(::tensorflow::SavedResource* resource);
732 private:
733 const ::tensorflow::SavedResource& _internal_resource() const;
734 ::tensorflow::SavedResource* _internal_mutable_resource();
735 public:
736 void unsafe_arena_set_allocated_resource(
737 ::tensorflow::SavedResource* resource);
738 ::tensorflow::SavedResource* unsafe_arena_release_resource();
739
740 // .tensorflow.CapturedTensor captured_tensor = 12;
741 bool has_captured_tensor() const;
742 private:
743 bool _internal_has_captured_tensor() const;
744 public:
745 void clear_captured_tensor();
746 const ::tensorflow::CapturedTensor& captured_tensor() const;
747 PROTOBUF_NODISCARD ::tensorflow::CapturedTensor* release_captured_tensor();
748 ::tensorflow::CapturedTensor* mutable_captured_tensor();
749 void set_allocated_captured_tensor(::tensorflow::CapturedTensor* captured_tensor);
750 private:
751 const ::tensorflow::CapturedTensor& _internal_captured_tensor() const;
752 ::tensorflow::CapturedTensor* _internal_mutable_captured_tensor();
753 public:
754 void unsafe_arena_set_allocated_captured_tensor(
755 ::tensorflow::CapturedTensor* captured_tensor);
756 ::tensorflow::CapturedTensor* unsafe_arena_release_captured_tensor();
757
758 void clear_kind();
759 KindCase kind_case() const;
760 // @@protoc_insertion_point(class_scope:tensorflow.SavedObject)
761 private:
762 class _Internal;
763 void set_has_user_object();
764 void set_has_asset();
765 void set_has_function();
766 void set_has_variable();
767 void set_has_bare_concrete_function();
768 void set_has_constant();
769 void set_has_resource();
770 void set_has_captured_tensor();
771
772 inline bool has_kind() const;
773 inline void clear_has_kind();
774
775 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
776 typedef void InternalArenaConstructable_;
777 typedef void DestructorSkippable_;
778 struct Impl_ {
779 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference > children_;
780 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference > slot_variables_;
781 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
782 SavedObject_SaveableObjectsEntry_DoNotUse,
783 std::string, ::tensorflow::SaveableObject,
784 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
785 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> saveable_objects_;
786 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference > dependencies_;
787 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr registered_name_;
788 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr registered_saver_;
789 ::PROTOBUF_NAMESPACE_ID::Any* serialized_user_proto_;
790 union KindUnion {
791 constexpr KindUnion() : _constinit_{} {}
792 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
793 ::tensorflow::SavedUserObject* user_object_;
794 ::tensorflow::SavedAsset* asset_;
795 ::tensorflow::SavedFunction* function_;
796 ::tensorflow::SavedVariable* variable_;
797 ::tensorflow::SavedBareConcreteFunction* bare_concrete_function_;
798 ::tensorflow::SavedConstant* constant_;
799 ::tensorflow::SavedResource* resource_;
800 ::tensorflow::CapturedTensor* captured_tensor_;
801 } kind_;
802 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
803 ::uint32_t _oneof_case_[1];
804
805 };
806 union { Impl_ _impl_; };
807 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
808 };
809 // -------------------------------------------------------------------
810
811 class SavedUserObject final :
812 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedUserObject) */ {
813 public:
SavedUserObject()814 inline SavedUserObject() : SavedUserObject(nullptr) {}
815 ~SavedUserObject() override;
816 explicit PROTOBUF_CONSTEXPR SavedUserObject(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
817
818 SavedUserObject(const SavedUserObject& from);
SavedUserObject(SavedUserObject && from)819 SavedUserObject(SavedUserObject&& from) noexcept
820 : SavedUserObject() {
821 *this = ::std::move(from);
822 }
823
824 inline SavedUserObject& operator=(const SavedUserObject& from) {
825 if (this == &from) return *this;
826 CopyFrom(from);
827 return *this;
828 }
829 inline SavedUserObject& operator=(SavedUserObject&& from) noexcept {
830 if (this == &from) return *this;
831 if (GetOwningArena() == from.GetOwningArena()
832 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
833 && GetOwningArena() != nullptr
834 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
835 ) {
836 InternalSwap(&from);
837 } else {
838 CopyFrom(from);
839 }
840 return *this;
841 }
842
default_instance()843 static const SavedUserObject& default_instance() {
844 return *internal_default_instance();
845 }
internal_default_instance()846 static inline const SavedUserObject* internal_default_instance() {
847 return reinterpret_cast<const SavedUserObject*>(
848 &_SavedUserObject_default_instance_);
849 }
850 static constexpr int kIndexInFileMessages =
851 4;
852
swap(SavedUserObject & a,SavedUserObject & b)853 friend void swap(SavedUserObject& a, SavedUserObject& b) {
854 a.Swap(&b);
855 }
Swap(SavedUserObject * other)856 inline void Swap(SavedUserObject* other) {
857 if (other == this) return;
858 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
859 if (GetOwningArena() != nullptr &&
860 GetOwningArena() == other->GetOwningArena()) {
861 #else // PROTOBUF_FORCE_COPY_IN_SWAP
862 if (GetOwningArena() == other->GetOwningArena()) {
863 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
864 InternalSwap(other);
865 } else {
866 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
867 }
868 }
869 void UnsafeArenaSwap(SavedUserObject* other) {
870 if (other == this) return;
871 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
872 InternalSwap(other);
873 }
874
875 // implements Message ----------------------------------------------
876
877 SavedUserObject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
878 return CreateMaybeMessage<SavedUserObject>(arena);
879 }
880 SavedUserObject* New() const {
881 return New(nullptr);
882 }
883 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
884 void CopyFrom(const SavedUserObject& from);
885 void MergeFrom(const SavedUserObject& from);
886 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
887 bool IsInitialized() const final;
888
889 size_t ByteSizeLong() const final;
890 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
891 ::uint8_t* _InternalSerialize(
892 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
893 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
894
895 private:
896 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
897 void SharedDtor();
898 void SetCachedSize(int size) const;
899 void InternalSwap(SavedUserObject* other);
900
901 private:
902 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
903 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
904 return "tensorflow.SavedUserObject";
905 }
906 protected:
907 explicit SavedUserObject(::PROTOBUF_NAMESPACE_ID::Arena* arena,
908 bool is_message_owned = false);
909 public:
910
911 std::string GetTypeName() const final;
912
913 // nested types ----------------------------------------------------
914
915 // accessors -------------------------------------------------------
916
917 enum : int {
918 kIdentifierFieldNumber = 1,
919 kMetadataFieldNumber = 3,
920 kVersionFieldNumber = 2,
921 };
922 // string identifier = 1;
923 void clear_identifier();
924 const std::string& identifier() const;
925 template <typename ArgT0 = const std::string&, typename... ArgT>
926 void set_identifier(ArgT0&& arg0, ArgT... args);
927 std::string* mutable_identifier();
928 PROTOBUF_NODISCARD std::string* release_identifier();
929 void set_allocated_identifier(std::string* identifier);
930 private:
931 const std::string& _internal_identifier() const;
932 inline PROTOBUF_ALWAYS_INLINE void _internal_set_identifier(const std::string& value);
933 std::string* _internal_mutable_identifier();
934 public:
935
936 // string metadata = 3 [deprecated = true];
937 PROTOBUF_DEPRECATED void clear_metadata();
938 PROTOBUF_DEPRECATED const std::string& metadata() const;
939 template <typename ArgT0 = const std::string&, typename... ArgT>
940 PROTOBUF_DEPRECATED void set_metadata(ArgT0&& arg0, ArgT... args);
941 PROTOBUF_DEPRECATED std::string* mutable_metadata();
942 PROTOBUF_NODISCARD PROTOBUF_DEPRECATED std::string* release_metadata();
943 PROTOBUF_DEPRECATED void set_allocated_metadata(std::string* metadata);
944 private:
945 const std::string& _internal_metadata() const;
946 inline PROTOBUF_ALWAYS_INLINE void _internal_set_metadata(const std::string& value);
947 std::string* _internal_mutable_metadata();
948 public:
949
950 // .tensorflow.VersionDef version = 2;
951 bool has_version() const;
952 private:
953 bool _internal_has_version() const;
954 public:
955 void clear_version();
956 const ::tensorflow::VersionDef& version() const;
957 PROTOBUF_NODISCARD ::tensorflow::VersionDef* release_version();
958 ::tensorflow::VersionDef* mutable_version();
959 void set_allocated_version(::tensorflow::VersionDef* version);
960 private:
961 const ::tensorflow::VersionDef& _internal_version() const;
962 ::tensorflow::VersionDef* _internal_mutable_version();
963 public:
964 void unsafe_arena_set_allocated_version(
965 ::tensorflow::VersionDef* version);
966 ::tensorflow::VersionDef* unsafe_arena_release_version();
967
968 // @@protoc_insertion_point(class_scope:tensorflow.SavedUserObject)
969 private:
970 class _Internal;
971
972 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
973 typedef void InternalArenaConstructable_;
974 typedef void DestructorSkippable_;
975 struct Impl_ {
976 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_;
977 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr metadata_;
978 ::tensorflow::VersionDef* version_;
979 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
980 };
981 union { Impl_ _impl_; };
982 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
983 };
984 // -------------------------------------------------------------------
985
986 class SavedAsset final :
987 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedAsset) */ {
988 public:
SavedAsset()989 inline SavedAsset() : SavedAsset(nullptr) {}
990 ~SavedAsset() override;
991 explicit PROTOBUF_CONSTEXPR SavedAsset(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
992
993 SavedAsset(const SavedAsset& from);
SavedAsset(SavedAsset && from)994 SavedAsset(SavedAsset&& from) noexcept
995 : SavedAsset() {
996 *this = ::std::move(from);
997 }
998
999 inline SavedAsset& operator=(const SavedAsset& from) {
1000 if (this == &from) return *this;
1001 CopyFrom(from);
1002 return *this;
1003 }
1004 inline SavedAsset& operator=(SavedAsset&& from) noexcept {
1005 if (this == &from) return *this;
1006 if (GetOwningArena() == from.GetOwningArena()
1007 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1008 && GetOwningArena() != nullptr
1009 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1010 ) {
1011 InternalSwap(&from);
1012 } else {
1013 CopyFrom(from);
1014 }
1015 return *this;
1016 }
1017
default_instance()1018 static const SavedAsset& default_instance() {
1019 return *internal_default_instance();
1020 }
internal_default_instance()1021 static inline const SavedAsset* internal_default_instance() {
1022 return reinterpret_cast<const SavedAsset*>(
1023 &_SavedAsset_default_instance_);
1024 }
1025 static constexpr int kIndexInFileMessages =
1026 5;
1027
swap(SavedAsset & a,SavedAsset & b)1028 friend void swap(SavedAsset& a, SavedAsset& b) {
1029 a.Swap(&b);
1030 }
Swap(SavedAsset * other)1031 inline void Swap(SavedAsset* other) {
1032 if (other == this) return;
1033 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1034 if (GetOwningArena() != nullptr &&
1035 GetOwningArena() == other->GetOwningArena()) {
1036 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1037 if (GetOwningArena() == other->GetOwningArena()) {
1038 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1039 InternalSwap(other);
1040 } else {
1041 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1042 }
1043 }
1044 void UnsafeArenaSwap(SavedAsset* other) {
1045 if (other == this) return;
1046 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1047 InternalSwap(other);
1048 }
1049
1050 // implements Message ----------------------------------------------
1051
1052 SavedAsset* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1053 return CreateMaybeMessage<SavedAsset>(arena);
1054 }
1055 SavedAsset* New() const {
1056 return New(nullptr);
1057 }
1058 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1059 void CopyFrom(const SavedAsset& from);
1060 void MergeFrom(const SavedAsset& from);
1061 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1062 bool IsInitialized() const final;
1063
1064 size_t ByteSizeLong() const final;
1065 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1066 ::uint8_t* _InternalSerialize(
1067 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1068 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1069
1070 private:
1071 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1072 void SharedDtor();
1073 void SetCachedSize(int size) const;
1074 void InternalSwap(SavedAsset* other);
1075
1076 private:
1077 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1078 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1079 return "tensorflow.SavedAsset";
1080 }
1081 protected:
1082 explicit SavedAsset(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1083 bool is_message_owned = false);
1084 public:
1085
1086 std::string GetTypeName() const final;
1087
1088 // nested types ----------------------------------------------------
1089
1090 // accessors -------------------------------------------------------
1091
1092 enum : int {
1093 kAssetFileDefIndexFieldNumber = 1,
1094 };
1095 // int32 asset_file_def_index = 1;
1096 void clear_asset_file_def_index();
1097 ::int32_t asset_file_def_index() const;
1098 void set_asset_file_def_index(::int32_t value);
1099 private:
1100 ::int32_t _internal_asset_file_def_index() const;
1101 void _internal_set_asset_file_def_index(::int32_t value);
1102 public:
1103
1104 // @@protoc_insertion_point(class_scope:tensorflow.SavedAsset)
1105 private:
1106 class _Internal;
1107
1108 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1109 typedef void InternalArenaConstructable_;
1110 typedef void DestructorSkippable_;
1111 struct Impl_ {
1112 ::int32_t asset_file_def_index_;
1113 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1114 };
1115 union { Impl_ _impl_; };
1116 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1117 };
1118 // -------------------------------------------------------------------
1119
1120 class SavedFunction final :
1121 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedFunction) */ {
1122 public:
SavedFunction()1123 inline SavedFunction() : SavedFunction(nullptr) {}
1124 ~SavedFunction() override;
1125 explicit PROTOBUF_CONSTEXPR SavedFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1126
1127 SavedFunction(const SavedFunction& from);
SavedFunction(SavedFunction && from)1128 SavedFunction(SavedFunction&& from) noexcept
1129 : SavedFunction() {
1130 *this = ::std::move(from);
1131 }
1132
1133 inline SavedFunction& operator=(const SavedFunction& from) {
1134 if (this == &from) return *this;
1135 CopyFrom(from);
1136 return *this;
1137 }
1138 inline SavedFunction& operator=(SavedFunction&& from) noexcept {
1139 if (this == &from) return *this;
1140 if (GetOwningArena() == from.GetOwningArena()
1141 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1142 && GetOwningArena() != nullptr
1143 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1144 ) {
1145 InternalSwap(&from);
1146 } else {
1147 CopyFrom(from);
1148 }
1149 return *this;
1150 }
1151
default_instance()1152 static const SavedFunction& default_instance() {
1153 return *internal_default_instance();
1154 }
internal_default_instance()1155 static inline const SavedFunction* internal_default_instance() {
1156 return reinterpret_cast<const SavedFunction*>(
1157 &_SavedFunction_default_instance_);
1158 }
1159 static constexpr int kIndexInFileMessages =
1160 6;
1161
swap(SavedFunction & a,SavedFunction & b)1162 friend void swap(SavedFunction& a, SavedFunction& b) {
1163 a.Swap(&b);
1164 }
Swap(SavedFunction * other)1165 inline void Swap(SavedFunction* other) {
1166 if (other == this) return;
1167 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1168 if (GetOwningArena() != nullptr &&
1169 GetOwningArena() == other->GetOwningArena()) {
1170 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1171 if (GetOwningArena() == other->GetOwningArena()) {
1172 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1173 InternalSwap(other);
1174 } else {
1175 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1176 }
1177 }
1178 void UnsafeArenaSwap(SavedFunction* other) {
1179 if (other == this) return;
1180 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1181 InternalSwap(other);
1182 }
1183
1184 // implements Message ----------------------------------------------
1185
1186 SavedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1187 return CreateMaybeMessage<SavedFunction>(arena);
1188 }
1189 SavedFunction* New() const {
1190 return New(nullptr);
1191 }
1192 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1193 void CopyFrom(const SavedFunction& from);
1194 void MergeFrom(const SavedFunction& from);
1195 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1196 bool IsInitialized() const final;
1197
1198 size_t ByteSizeLong() const final;
1199 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1200 ::uint8_t* _InternalSerialize(
1201 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1202 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1203
1204 private:
1205 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1206 void SharedDtor();
1207 void SetCachedSize(int size) const;
1208 void InternalSwap(SavedFunction* other);
1209
1210 private:
1211 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1212 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1213 return "tensorflow.SavedFunction";
1214 }
1215 protected:
1216 explicit SavedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1217 bool is_message_owned = false);
1218 public:
1219
1220 std::string GetTypeName() const final;
1221
1222 // nested types ----------------------------------------------------
1223
1224 // accessors -------------------------------------------------------
1225
1226 enum : int {
1227 kConcreteFunctionsFieldNumber = 1,
1228 kFunctionSpecFieldNumber = 2,
1229 };
1230 // repeated string concrete_functions = 1;
1231 int concrete_functions_size() const;
1232 private:
1233 int _internal_concrete_functions_size() const;
1234 public:
1235 void clear_concrete_functions();
1236 const std::string& concrete_functions(int index) const;
1237 std::string* mutable_concrete_functions(int index);
1238 void set_concrete_functions(int index, const std::string& value);
1239 void set_concrete_functions(int index, std::string&& value);
1240 void set_concrete_functions(int index, const char* value);
1241 void set_concrete_functions(int index, const char* value, size_t size);
1242 std::string* add_concrete_functions();
1243 void add_concrete_functions(const std::string& value);
1244 void add_concrete_functions(std::string&& value);
1245 void add_concrete_functions(const char* value);
1246 void add_concrete_functions(const char* value, size_t size);
1247 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& concrete_functions() const;
1248 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_concrete_functions();
1249 private:
1250 const std::string& _internal_concrete_functions(int index) const;
1251 std::string* _internal_add_concrete_functions();
1252 public:
1253
1254 // .tensorflow.FunctionSpec function_spec = 2;
1255 bool has_function_spec() const;
1256 private:
1257 bool _internal_has_function_spec() const;
1258 public:
1259 void clear_function_spec();
1260 const ::tensorflow::FunctionSpec& function_spec() const;
1261 PROTOBUF_NODISCARD ::tensorflow::FunctionSpec* release_function_spec();
1262 ::tensorflow::FunctionSpec* mutable_function_spec();
1263 void set_allocated_function_spec(::tensorflow::FunctionSpec* function_spec);
1264 private:
1265 const ::tensorflow::FunctionSpec& _internal_function_spec() const;
1266 ::tensorflow::FunctionSpec* _internal_mutable_function_spec();
1267 public:
1268 void unsafe_arena_set_allocated_function_spec(
1269 ::tensorflow::FunctionSpec* function_spec);
1270 ::tensorflow::FunctionSpec* unsafe_arena_release_function_spec();
1271
1272 // @@protoc_insertion_point(class_scope:tensorflow.SavedFunction)
1273 private:
1274 class _Internal;
1275
1276 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1277 typedef void InternalArenaConstructable_;
1278 typedef void DestructorSkippable_;
1279 struct Impl_ {
1280 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> concrete_functions_;
1281 ::tensorflow::FunctionSpec* function_spec_;
1282 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1283 };
1284 union { Impl_ _impl_; };
1285 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1286 };
1287 // -------------------------------------------------------------------
1288
1289 class CapturedTensor final :
1290 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CapturedTensor) */ {
1291 public:
CapturedTensor()1292 inline CapturedTensor() : CapturedTensor(nullptr) {}
1293 ~CapturedTensor() override;
1294 explicit PROTOBUF_CONSTEXPR CapturedTensor(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1295
1296 CapturedTensor(const CapturedTensor& from);
CapturedTensor(CapturedTensor && from)1297 CapturedTensor(CapturedTensor&& from) noexcept
1298 : CapturedTensor() {
1299 *this = ::std::move(from);
1300 }
1301
1302 inline CapturedTensor& operator=(const CapturedTensor& from) {
1303 if (this == &from) return *this;
1304 CopyFrom(from);
1305 return *this;
1306 }
1307 inline CapturedTensor& operator=(CapturedTensor&& from) noexcept {
1308 if (this == &from) return *this;
1309 if (GetOwningArena() == from.GetOwningArena()
1310 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1311 && GetOwningArena() != nullptr
1312 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1313 ) {
1314 InternalSwap(&from);
1315 } else {
1316 CopyFrom(from);
1317 }
1318 return *this;
1319 }
1320
default_instance()1321 static const CapturedTensor& default_instance() {
1322 return *internal_default_instance();
1323 }
internal_default_instance()1324 static inline const CapturedTensor* internal_default_instance() {
1325 return reinterpret_cast<const CapturedTensor*>(
1326 &_CapturedTensor_default_instance_);
1327 }
1328 static constexpr int kIndexInFileMessages =
1329 7;
1330
swap(CapturedTensor & a,CapturedTensor & b)1331 friend void swap(CapturedTensor& a, CapturedTensor& b) {
1332 a.Swap(&b);
1333 }
Swap(CapturedTensor * other)1334 inline void Swap(CapturedTensor* other) {
1335 if (other == this) return;
1336 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1337 if (GetOwningArena() != nullptr &&
1338 GetOwningArena() == other->GetOwningArena()) {
1339 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1340 if (GetOwningArena() == other->GetOwningArena()) {
1341 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1342 InternalSwap(other);
1343 } else {
1344 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1345 }
1346 }
1347 void UnsafeArenaSwap(CapturedTensor* other) {
1348 if (other == this) return;
1349 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1350 InternalSwap(other);
1351 }
1352
1353 // implements Message ----------------------------------------------
1354
1355 CapturedTensor* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1356 return CreateMaybeMessage<CapturedTensor>(arena);
1357 }
1358 CapturedTensor* New() const {
1359 return New(nullptr);
1360 }
1361 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1362 void CopyFrom(const CapturedTensor& from);
1363 void MergeFrom(const CapturedTensor& from);
1364 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1365 bool IsInitialized() const final;
1366
1367 size_t ByteSizeLong() const final;
1368 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1369 ::uint8_t* _InternalSerialize(
1370 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1371 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1372
1373 private:
1374 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1375 void SharedDtor();
1376 void SetCachedSize(int size) const;
1377 void InternalSwap(CapturedTensor* other);
1378
1379 private:
1380 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1381 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1382 return "tensorflow.CapturedTensor";
1383 }
1384 protected:
1385 explicit CapturedTensor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1386 bool is_message_owned = false);
1387 public:
1388
1389 std::string GetTypeName() const final;
1390
1391 // nested types ----------------------------------------------------
1392
1393 // accessors -------------------------------------------------------
1394
1395 enum : int {
1396 kNameFieldNumber = 1,
1397 kConcreteFunctionFieldNumber = 2,
1398 };
1399 // string name = 1;
1400 void clear_name();
1401 const std::string& name() const;
1402 template <typename ArgT0 = const std::string&, typename... ArgT>
1403 void set_name(ArgT0&& arg0, ArgT... args);
1404 std::string* mutable_name();
1405 PROTOBUF_NODISCARD std::string* release_name();
1406 void set_allocated_name(std::string* name);
1407 private:
1408 const std::string& _internal_name() const;
1409 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1410 std::string* _internal_mutable_name();
1411 public:
1412
1413 // string concrete_function = 2;
1414 void clear_concrete_function();
1415 const std::string& concrete_function() const;
1416 template <typename ArgT0 = const std::string&, typename... ArgT>
1417 void set_concrete_function(ArgT0&& arg0, ArgT... args);
1418 std::string* mutable_concrete_function();
1419 PROTOBUF_NODISCARD std::string* release_concrete_function();
1420 void set_allocated_concrete_function(std::string* concrete_function);
1421 private:
1422 const std::string& _internal_concrete_function() const;
1423 inline PROTOBUF_ALWAYS_INLINE void _internal_set_concrete_function(const std::string& value);
1424 std::string* _internal_mutable_concrete_function();
1425 public:
1426
1427 // @@protoc_insertion_point(class_scope:tensorflow.CapturedTensor)
1428 private:
1429 class _Internal;
1430
1431 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1432 typedef void InternalArenaConstructable_;
1433 typedef void DestructorSkippable_;
1434 struct Impl_ {
1435 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1436 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr concrete_function_;
1437 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1438 };
1439 union { Impl_ _impl_; };
1440 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1441 };
1442 // -------------------------------------------------------------------
1443
1444 class SavedConcreteFunction final :
1445 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedConcreteFunction) */ {
1446 public:
SavedConcreteFunction()1447 inline SavedConcreteFunction() : SavedConcreteFunction(nullptr) {}
1448 ~SavedConcreteFunction() override;
1449 explicit PROTOBUF_CONSTEXPR SavedConcreteFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1450
1451 SavedConcreteFunction(const SavedConcreteFunction& from);
SavedConcreteFunction(SavedConcreteFunction && from)1452 SavedConcreteFunction(SavedConcreteFunction&& from) noexcept
1453 : SavedConcreteFunction() {
1454 *this = ::std::move(from);
1455 }
1456
1457 inline SavedConcreteFunction& operator=(const SavedConcreteFunction& from) {
1458 if (this == &from) return *this;
1459 CopyFrom(from);
1460 return *this;
1461 }
1462 inline SavedConcreteFunction& operator=(SavedConcreteFunction&& from) noexcept {
1463 if (this == &from) return *this;
1464 if (GetOwningArena() == from.GetOwningArena()
1465 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1466 && GetOwningArena() != nullptr
1467 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1468 ) {
1469 InternalSwap(&from);
1470 } else {
1471 CopyFrom(from);
1472 }
1473 return *this;
1474 }
1475
default_instance()1476 static const SavedConcreteFunction& default_instance() {
1477 return *internal_default_instance();
1478 }
internal_default_instance()1479 static inline const SavedConcreteFunction* internal_default_instance() {
1480 return reinterpret_cast<const SavedConcreteFunction*>(
1481 &_SavedConcreteFunction_default_instance_);
1482 }
1483 static constexpr int kIndexInFileMessages =
1484 8;
1485
swap(SavedConcreteFunction & a,SavedConcreteFunction & b)1486 friend void swap(SavedConcreteFunction& a, SavedConcreteFunction& b) {
1487 a.Swap(&b);
1488 }
Swap(SavedConcreteFunction * other)1489 inline void Swap(SavedConcreteFunction* other) {
1490 if (other == this) return;
1491 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1492 if (GetOwningArena() != nullptr &&
1493 GetOwningArena() == other->GetOwningArena()) {
1494 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1495 if (GetOwningArena() == other->GetOwningArena()) {
1496 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1497 InternalSwap(other);
1498 } else {
1499 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1500 }
1501 }
1502 void UnsafeArenaSwap(SavedConcreteFunction* other) {
1503 if (other == this) return;
1504 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1505 InternalSwap(other);
1506 }
1507
1508 // implements Message ----------------------------------------------
1509
1510 SavedConcreteFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1511 return CreateMaybeMessage<SavedConcreteFunction>(arena);
1512 }
1513 SavedConcreteFunction* New() const {
1514 return New(nullptr);
1515 }
1516 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1517 void CopyFrom(const SavedConcreteFunction& from);
1518 void MergeFrom(const SavedConcreteFunction& from);
1519 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1520 bool IsInitialized() const final;
1521
1522 size_t ByteSizeLong() const final;
1523 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1524 ::uint8_t* _InternalSerialize(
1525 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1526 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1527
1528 private:
1529 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1530 void SharedDtor();
1531 void SetCachedSize(int size) const;
1532 void InternalSwap(SavedConcreteFunction* other);
1533
1534 private:
1535 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1536 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1537 return "tensorflow.SavedConcreteFunction";
1538 }
1539 protected:
1540 explicit SavedConcreteFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1541 bool is_message_owned = false);
1542 public:
1543
1544 std::string GetTypeName() const final;
1545
1546 // nested types ----------------------------------------------------
1547
1548 // accessors -------------------------------------------------------
1549
1550 enum : int {
1551 kBoundInputsFieldNumber = 2,
1552 kCanonicalizedInputSignatureFieldNumber = 3,
1553 kOutputSignatureFieldNumber = 4,
1554 };
1555 // repeated int32 bound_inputs = 2;
1556 int bound_inputs_size() const;
1557 private:
1558 int _internal_bound_inputs_size() const;
1559 public:
1560 void clear_bound_inputs();
1561 private:
1562 ::int32_t _internal_bound_inputs(int index) const;
1563 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
1564 _internal_bound_inputs() const;
1565 void _internal_add_bound_inputs(::int32_t value);
1566 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
1567 _internal_mutable_bound_inputs();
1568 public:
1569 ::int32_t bound_inputs(int index) const;
1570 void set_bound_inputs(int index, ::int32_t value);
1571 void add_bound_inputs(::int32_t value);
1572 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
1573 bound_inputs() const;
1574 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
1575 mutable_bound_inputs();
1576
1577 // .tensorflow.StructuredValue canonicalized_input_signature = 3;
1578 bool has_canonicalized_input_signature() const;
1579 private:
1580 bool _internal_has_canonicalized_input_signature() const;
1581 public:
1582 void clear_canonicalized_input_signature();
1583 const ::tensorflow::StructuredValue& canonicalized_input_signature() const;
1584 PROTOBUF_NODISCARD ::tensorflow::StructuredValue* release_canonicalized_input_signature();
1585 ::tensorflow::StructuredValue* mutable_canonicalized_input_signature();
1586 void set_allocated_canonicalized_input_signature(::tensorflow::StructuredValue* canonicalized_input_signature);
1587 private:
1588 const ::tensorflow::StructuredValue& _internal_canonicalized_input_signature() const;
1589 ::tensorflow::StructuredValue* _internal_mutable_canonicalized_input_signature();
1590 public:
1591 void unsafe_arena_set_allocated_canonicalized_input_signature(
1592 ::tensorflow::StructuredValue* canonicalized_input_signature);
1593 ::tensorflow::StructuredValue* unsafe_arena_release_canonicalized_input_signature();
1594
1595 // .tensorflow.StructuredValue output_signature = 4;
1596 bool has_output_signature() const;
1597 private:
1598 bool _internal_has_output_signature() const;
1599 public:
1600 void clear_output_signature();
1601 const ::tensorflow::StructuredValue& output_signature() const;
1602 PROTOBUF_NODISCARD ::tensorflow::StructuredValue* release_output_signature();
1603 ::tensorflow::StructuredValue* mutable_output_signature();
1604 void set_allocated_output_signature(::tensorflow::StructuredValue* output_signature);
1605 private:
1606 const ::tensorflow::StructuredValue& _internal_output_signature() const;
1607 ::tensorflow::StructuredValue* _internal_mutable_output_signature();
1608 public:
1609 void unsafe_arena_set_allocated_output_signature(
1610 ::tensorflow::StructuredValue* output_signature);
1611 ::tensorflow::StructuredValue* unsafe_arena_release_output_signature();
1612
1613 // @@protoc_insertion_point(class_scope:tensorflow.SavedConcreteFunction)
1614 private:
1615 class _Internal;
1616
1617 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1618 typedef void InternalArenaConstructable_;
1619 typedef void DestructorSkippable_;
1620 struct Impl_ {
1621 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t > bound_inputs_;
1622 mutable std::atomic<int> _bound_inputs_cached_byte_size_;
1623 ::tensorflow::StructuredValue* canonicalized_input_signature_;
1624 ::tensorflow::StructuredValue* output_signature_;
1625 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1626 };
1627 union { Impl_ _impl_; };
1628 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1629 };
1630 // -------------------------------------------------------------------
1631
1632 class SavedBareConcreteFunction final :
1633 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedBareConcreteFunction) */ {
1634 public:
SavedBareConcreteFunction()1635 inline SavedBareConcreteFunction() : SavedBareConcreteFunction(nullptr) {}
1636 ~SavedBareConcreteFunction() override;
1637 explicit PROTOBUF_CONSTEXPR SavedBareConcreteFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1638
1639 SavedBareConcreteFunction(const SavedBareConcreteFunction& from);
SavedBareConcreteFunction(SavedBareConcreteFunction && from)1640 SavedBareConcreteFunction(SavedBareConcreteFunction&& from) noexcept
1641 : SavedBareConcreteFunction() {
1642 *this = ::std::move(from);
1643 }
1644
1645 inline SavedBareConcreteFunction& operator=(const SavedBareConcreteFunction& from) {
1646 if (this == &from) return *this;
1647 CopyFrom(from);
1648 return *this;
1649 }
1650 inline SavedBareConcreteFunction& operator=(SavedBareConcreteFunction&& from) noexcept {
1651 if (this == &from) return *this;
1652 if (GetOwningArena() == from.GetOwningArena()
1653 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1654 && GetOwningArena() != nullptr
1655 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1656 ) {
1657 InternalSwap(&from);
1658 } else {
1659 CopyFrom(from);
1660 }
1661 return *this;
1662 }
1663
default_instance()1664 static const SavedBareConcreteFunction& default_instance() {
1665 return *internal_default_instance();
1666 }
internal_default_instance()1667 static inline const SavedBareConcreteFunction* internal_default_instance() {
1668 return reinterpret_cast<const SavedBareConcreteFunction*>(
1669 &_SavedBareConcreteFunction_default_instance_);
1670 }
1671 static constexpr int kIndexInFileMessages =
1672 9;
1673
swap(SavedBareConcreteFunction & a,SavedBareConcreteFunction & b)1674 friend void swap(SavedBareConcreteFunction& a, SavedBareConcreteFunction& b) {
1675 a.Swap(&b);
1676 }
Swap(SavedBareConcreteFunction * other)1677 inline void Swap(SavedBareConcreteFunction* other) {
1678 if (other == this) return;
1679 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1680 if (GetOwningArena() != nullptr &&
1681 GetOwningArena() == other->GetOwningArena()) {
1682 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1683 if (GetOwningArena() == other->GetOwningArena()) {
1684 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1685 InternalSwap(other);
1686 } else {
1687 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1688 }
1689 }
1690 void UnsafeArenaSwap(SavedBareConcreteFunction* other) {
1691 if (other == this) return;
1692 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1693 InternalSwap(other);
1694 }
1695
1696 // implements Message ----------------------------------------------
1697
1698 SavedBareConcreteFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1699 return CreateMaybeMessage<SavedBareConcreteFunction>(arena);
1700 }
1701 SavedBareConcreteFunction* New() const {
1702 return New(nullptr);
1703 }
1704 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1705 void CopyFrom(const SavedBareConcreteFunction& from);
1706 void MergeFrom(const SavedBareConcreteFunction& from);
1707 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1708 bool IsInitialized() const final;
1709
1710 size_t ByteSizeLong() const final;
1711 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1712 ::uint8_t* _InternalSerialize(
1713 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1714 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1715
1716 private:
1717 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1718 void SharedDtor();
1719 void SetCachedSize(int size) const;
1720 void InternalSwap(SavedBareConcreteFunction* other);
1721
1722 private:
1723 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1724 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1725 return "tensorflow.SavedBareConcreteFunction";
1726 }
1727 protected:
1728 explicit SavedBareConcreteFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1729 bool is_message_owned = false);
1730 public:
1731
1732 std::string GetTypeName() const final;
1733
1734 // nested types ----------------------------------------------------
1735
1736 // accessors -------------------------------------------------------
1737
1738 enum : int {
1739 kArgumentKeywordsFieldNumber = 2,
1740 kConcreteFunctionNameFieldNumber = 1,
1741 kFunctionSpecFieldNumber = 4,
1742 kAllowedPositionalArgumentsFieldNumber = 3,
1743 };
1744 // repeated string argument_keywords = 2;
1745 int argument_keywords_size() const;
1746 private:
1747 int _internal_argument_keywords_size() const;
1748 public:
1749 void clear_argument_keywords();
1750 const std::string& argument_keywords(int index) const;
1751 std::string* mutable_argument_keywords(int index);
1752 void set_argument_keywords(int index, const std::string& value);
1753 void set_argument_keywords(int index, std::string&& value);
1754 void set_argument_keywords(int index, const char* value);
1755 void set_argument_keywords(int index, const char* value, size_t size);
1756 std::string* add_argument_keywords();
1757 void add_argument_keywords(const std::string& value);
1758 void add_argument_keywords(std::string&& value);
1759 void add_argument_keywords(const char* value);
1760 void add_argument_keywords(const char* value, size_t size);
1761 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& argument_keywords() const;
1762 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_argument_keywords();
1763 private:
1764 const std::string& _internal_argument_keywords(int index) const;
1765 std::string* _internal_add_argument_keywords();
1766 public:
1767
1768 // string concrete_function_name = 1;
1769 void clear_concrete_function_name();
1770 const std::string& concrete_function_name() const;
1771 template <typename ArgT0 = const std::string&, typename... ArgT>
1772 void set_concrete_function_name(ArgT0&& arg0, ArgT... args);
1773 std::string* mutable_concrete_function_name();
1774 PROTOBUF_NODISCARD std::string* release_concrete_function_name();
1775 void set_allocated_concrete_function_name(std::string* concrete_function_name);
1776 private:
1777 const std::string& _internal_concrete_function_name() const;
1778 inline PROTOBUF_ALWAYS_INLINE void _internal_set_concrete_function_name(const std::string& value);
1779 std::string* _internal_mutable_concrete_function_name();
1780 public:
1781
1782 // .tensorflow.FunctionSpec function_spec = 4;
1783 bool has_function_spec() const;
1784 private:
1785 bool _internal_has_function_spec() const;
1786 public:
1787 void clear_function_spec();
1788 const ::tensorflow::FunctionSpec& function_spec() const;
1789 PROTOBUF_NODISCARD ::tensorflow::FunctionSpec* release_function_spec();
1790 ::tensorflow::FunctionSpec* mutable_function_spec();
1791 void set_allocated_function_spec(::tensorflow::FunctionSpec* function_spec);
1792 private:
1793 const ::tensorflow::FunctionSpec& _internal_function_spec() const;
1794 ::tensorflow::FunctionSpec* _internal_mutable_function_spec();
1795 public:
1796 void unsafe_arena_set_allocated_function_spec(
1797 ::tensorflow::FunctionSpec* function_spec);
1798 ::tensorflow::FunctionSpec* unsafe_arena_release_function_spec();
1799
1800 // int64 allowed_positional_arguments = 3;
1801 void clear_allowed_positional_arguments();
1802 ::int64_t allowed_positional_arguments() const;
1803 void set_allowed_positional_arguments(::int64_t value);
1804 private:
1805 ::int64_t _internal_allowed_positional_arguments() const;
1806 void _internal_set_allowed_positional_arguments(::int64_t value);
1807 public:
1808
1809 // @@protoc_insertion_point(class_scope:tensorflow.SavedBareConcreteFunction)
1810 private:
1811 class _Internal;
1812
1813 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1814 typedef void InternalArenaConstructable_;
1815 typedef void DestructorSkippable_;
1816 struct Impl_ {
1817 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> argument_keywords_;
1818 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr concrete_function_name_;
1819 ::tensorflow::FunctionSpec* function_spec_;
1820 ::int64_t allowed_positional_arguments_;
1821 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1822 };
1823 union { Impl_ _impl_; };
1824 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1825 };
1826 // -------------------------------------------------------------------
1827
1828 class SavedConstant final :
1829 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedConstant) */ {
1830 public:
SavedConstant()1831 inline SavedConstant() : SavedConstant(nullptr) {}
1832 ~SavedConstant() override;
1833 explicit PROTOBUF_CONSTEXPR SavedConstant(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1834
1835 SavedConstant(const SavedConstant& from);
SavedConstant(SavedConstant && from)1836 SavedConstant(SavedConstant&& from) noexcept
1837 : SavedConstant() {
1838 *this = ::std::move(from);
1839 }
1840
1841 inline SavedConstant& operator=(const SavedConstant& from) {
1842 if (this == &from) return *this;
1843 CopyFrom(from);
1844 return *this;
1845 }
1846 inline SavedConstant& operator=(SavedConstant&& from) noexcept {
1847 if (this == &from) return *this;
1848 if (GetOwningArena() == from.GetOwningArena()
1849 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1850 && GetOwningArena() != nullptr
1851 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1852 ) {
1853 InternalSwap(&from);
1854 } else {
1855 CopyFrom(from);
1856 }
1857 return *this;
1858 }
1859
default_instance()1860 static const SavedConstant& default_instance() {
1861 return *internal_default_instance();
1862 }
internal_default_instance()1863 static inline const SavedConstant* internal_default_instance() {
1864 return reinterpret_cast<const SavedConstant*>(
1865 &_SavedConstant_default_instance_);
1866 }
1867 static constexpr int kIndexInFileMessages =
1868 10;
1869
swap(SavedConstant & a,SavedConstant & b)1870 friend void swap(SavedConstant& a, SavedConstant& b) {
1871 a.Swap(&b);
1872 }
Swap(SavedConstant * other)1873 inline void Swap(SavedConstant* other) {
1874 if (other == this) return;
1875 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1876 if (GetOwningArena() != nullptr &&
1877 GetOwningArena() == other->GetOwningArena()) {
1878 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1879 if (GetOwningArena() == other->GetOwningArena()) {
1880 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1881 InternalSwap(other);
1882 } else {
1883 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1884 }
1885 }
1886 void UnsafeArenaSwap(SavedConstant* other) {
1887 if (other == this) return;
1888 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1889 InternalSwap(other);
1890 }
1891
1892 // implements Message ----------------------------------------------
1893
1894 SavedConstant* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1895 return CreateMaybeMessage<SavedConstant>(arena);
1896 }
1897 SavedConstant* New() const {
1898 return New(nullptr);
1899 }
1900 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1901 void CopyFrom(const SavedConstant& from);
1902 void MergeFrom(const SavedConstant& from);
1903 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1904 bool IsInitialized() const final;
1905
1906 size_t ByteSizeLong() const final;
1907 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1908 ::uint8_t* _InternalSerialize(
1909 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1910 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1911
1912 private:
1913 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1914 void SharedDtor();
1915 void SetCachedSize(int size) const;
1916 void InternalSwap(SavedConstant* other);
1917
1918 private:
1919 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1920 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1921 return "tensorflow.SavedConstant";
1922 }
1923 protected:
1924 explicit SavedConstant(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1925 bool is_message_owned = false);
1926 public:
1927
1928 std::string GetTypeName() const final;
1929
1930 // nested types ----------------------------------------------------
1931
1932 // accessors -------------------------------------------------------
1933
1934 enum : int {
1935 kOperationFieldNumber = 1,
1936 };
1937 // string operation = 1;
1938 void clear_operation();
1939 const std::string& operation() const;
1940 template <typename ArgT0 = const std::string&, typename... ArgT>
1941 void set_operation(ArgT0&& arg0, ArgT... args);
1942 std::string* mutable_operation();
1943 PROTOBUF_NODISCARD std::string* release_operation();
1944 void set_allocated_operation(std::string* operation);
1945 private:
1946 const std::string& _internal_operation() const;
1947 inline PROTOBUF_ALWAYS_INLINE void _internal_set_operation(const std::string& value);
1948 std::string* _internal_mutable_operation();
1949 public:
1950
1951 // @@protoc_insertion_point(class_scope:tensorflow.SavedConstant)
1952 private:
1953 class _Internal;
1954
1955 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1956 typedef void InternalArenaConstructable_;
1957 typedef void DestructorSkippable_;
1958 struct Impl_ {
1959 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr operation_;
1960 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1961 };
1962 union { Impl_ _impl_; };
1963 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
1964 };
1965 // -------------------------------------------------------------------
1966
1967 class SavedVariable final :
1968 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedVariable) */ {
1969 public:
SavedVariable()1970 inline SavedVariable() : SavedVariable(nullptr) {}
1971 ~SavedVariable() override;
1972 explicit PROTOBUF_CONSTEXPR SavedVariable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1973
1974 SavedVariable(const SavedVariable& from);
SavedVariable(SavedVariable && from)1975 SavedVariable(SavedVariable&& from) noexcept
1976 : SavedVariable() {
1977 *this = ::std::move(from);
1978 }
1979
1980 inline SavedVariable& operator=(const SavedVariable& from) {
1981 if (this == &from) return *this;
1982 CopyFrom(from);
1983 return *this;
1984 }
1985 inline SavedVariable& operator=(SavedVariable&& from) noexcept {
1986 if (this == &from) return *this;
1987 if (GetOwningArena() == from.GetOwningArena()
1988 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1989 && GetOwningArena() != nullptr
1990 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1991 ) {
1992 InternalSwap(&from);
1993 } else {
1994 CopyFrom(from);
1995 }
1996 return *this;
1997 }
1998
default_instance()1999 static const SavedVariable& default_instance() {
2000 return *internal_default_instance();
2001 }
internal_default_instance()2002 static inline const SavedVariable* internal_default_instance() {
2003 return reinterpret_cast<const SavedVariable*>(
2004 &_SavedVariable_default_instance_);
2005 }
2006 static constexpr int kIndexInFileMessages =
2007 11;
2008
swap(SavedVariable & a,SavedVariable & b)2009 friend void swap(SavedVariable& a, SavedVariable& b) {
2010 a.Swap(&b);
2011 }
Swap(SavedVariable * other)2012 inline void Swap(SavedVariable* other) {
2013 if (other == this) return;
2014 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2015 if (GetOwningArena() != nullptr &&
2016 GetOwningArena() == other->GetOwningArena()) {
2017 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2018 if (GetOwningArena() == other->GetOwningArena()) {
2019 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2020 InternalSwap(other);
2021 } else {
2022 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2023 }
2024 }
2025 void UnsafeArenaSwap(SavedVariable* other) {
2026 if (other == this) return;
2027 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2028 InternalSwap(other);
2029 }
2030
2031 // implements Message ----------------------------------------------
2032
2033 SavedVariable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2034 return CreateMaybeMessage<SavedVariable>(arena);
2035 }
2036 SavedVariable* New() const {
2037 return New(nullptr);
2038 }
2039 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2040 void CopyFrom(const SavedVariable& from);
2041 void MergeFrom(const SavedVariable& from);
2042 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2043 bool IsInitialized() const final;
2044
2045 size_t ByteSizeLong() const final;
2046 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2047 ::uint8_t* _InternalSerialize(
2048 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2049 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2050
2051 private:
2052 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2053 void SharedDtor();
2054 void SetCachedSize(int size) const;
2055 void InternalSwap(SavedVariable* other);
2056
2057 private:
2058 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2059 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2060 return "tensorflow.SavedVariable";
2061 }
2062 protected:
2063 explicit SavedVariable(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2064 bool is_message_owned = false);
2065 public:
2066
2067 std::string GetTypeName() const final;
2068
2069 // nested types ----------------------------------------------------
2070
2071 // accessors -------------------------------------------------------
2072
2073 enum : int {
2074 kExperimentalDistributedVariableComponentsFieldNumber = 8,
2075 kNameFieldNumber = 6,
2076 kDeviceFieldNumber = 7,
2077 kShapeFieldNumber = 2,
2078 kDtypeFieldNumber = 1,
2079 kTrainableFieldNumber = 3,
2080 kSynchronizationFieldNumber = 4,
2081 kAggregationFieldNumber = 5,
2082 };
2083 // repeated .tensorflow.SavedVariable experimental_distributed_variable_components = 8;
2084 int experimental_distributed_variable_components_size() const;
2085 private:
2086 int _internal_experimental_distributed_variable_components_size() const;
2087 public:
2088 void clear_experimental_distributed_variable_components();
2089 ::tensorflow::SavedVariable* mutable_experimental_distributed_variable_components(int index);
2090 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedVariable >*
2091 mutable_experimental_distributed_variable_components();
2092 private:
2093 const ::tensorflow::SavedVariable& _internal_experimental_distributed_variable_components(int index) const;
2094 ::tensorflow::SavedVariable* _internal_add_experimental_distributed_variable_components();
2095 public:
2096 const ::tensorflow::SavedVariable& experimental_distributed_variable_components(int index) const;
2097 ::tensorflow::SavedVariable* add_experimental_distributed_variable_components();
2098 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedVariable >&
2099 experimental_distributed_variable_components() const;
2100
2101 // string name = 6;
2102 void clear_name();
2103 const std::string& name() const;
2104 template <typename ArgT0 = const std::string&, typename... ArgT>
2105 void set_name(ArgT0&& arg0, ArgT... args);
2106 std::string* mutable_name();
2107 PROTOBUF_NODISCARD std::string* release_name();
2108 void set_allocated_name(std::string* name);
2109 private:
2110 const std::string& _internal_name() const;
2111 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
2112 std::string* _internal_mutable_name();
2113 public:
2114
2115 // string device = 7;
2116 void clear_device();
2117 const std::string& device() const;
2118 template <typename ArgT0 = const std::string&, typename... ArgT>
2119 void set_device(ArgT0&& arg0, ArgT... args);
2120 std::string* mutable_device();
2121 PROTOBUF_NODISCARD std::string* release_device();
2122 void set_allocated_device(std::string* device);
2123 private:
2124 const std::string& _internal_device() const;
2125 inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
2126 std::string* _internal_mutable_device();
2127 public:
2128
2129 // .tensorflow.TensorShapeProto shape = 2;
2130 bool has_shape() const;
2131 private:
2132 bool _internal_has_shape() const;
2133 public:
2134 void clear_shape();
2135 const ::tensorflow::TensorShapeProto& shape() const;
2136 PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
2137 ::tensorflow::TensorShapeProto* mutable_shape();
2138 void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
2139 private:
2140 const ::tensorflow::TensorShapeProto& _internal_shape() const;
2141 ::tensorflow::TensorShapeProto* _internal_mutable_shape();
2142 public:
2143 void unsafe_arena_set_allocated_shape(
2144 ::tensorflow::TensorShapeProto* shape);
2145 ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
2146
2147 // .tensorflow.DataType dtype = 1;
2148 void clear_dtype();
2149 ::tensorflow::DataType dtype() const;
2150 void set_dtype(::tensorflow::DataType value);
2151 private:
2152 ::tensorflow::DataType _internal_dtype() const;
2153 void _internal_set_dtype(::tensorflow::DataType value);
2154 public:
2155
2156 // bool trainable = 3;
2157 void clear_trainable();
2158 bool trainable() const;
2159 void set_trainable(bool value);
2160 private:
2161 bool _internal_trainable() const;
2162 void _internal_set_trainable(bool value);
2163 public:
2164
2165 // .tensorflow.VariableSynchronization synchronization = 4;
2166 void clear_synchronization();
2167 ::tensorflow::VariableSynchronization synchronization() const;
2168 void set_synchronization(::tensorflow::VariableSynchronization value);
2169 private:
2170 ::tensorflow::VariableSynchronization _internal_synchronization() const;
2171 void _internal_set_synchronization(::tensorflow::VariableSynchronization value);
2172 public:
2173
2174 // .tensorflow.VariableAggregation aggregation = 5;
2175 void clear_aggregation();
2176 ::tensorflow::VariableAggregation aggregation() const;
2177 void set_aggregation(::tensorflow::VariableAggregation value);
2178 private:
2179 ::tensorflow::VariableAggregation _internal_aggregation() const;
2180 void _internal_set_aggregation(::tensorflow::VariableAggregation value);
2181 public:
2182
2183 // @@protoc_insertion_point(class_scope:tensorflow.SavedVariable)
2184 private:
2185 class _Internal;
2186
2187 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2188 typedef void InternalArenaConstructable_;
2189 typedef void DestructorSkippable_;
2190 struct Impl_ {
2191 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedVariable > experimental_distributed_variable_components_;
2192 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2193 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
2194 ::tensorflow::TensorShapeProto* shape_;
2195 int dtype_;
2196 bool trainable_;
2197 int synchronization_;
2198 int aggregation_;
2199 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2200 };
2201 union { Impl_ _impl_; };
2202 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
2203 };
2204 // -------------------------------------------------------------------
2205
2206 class FunctionSpec final :
2207 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.FunctionSpec) */ {
2208 public:
FunctionSpec()2209 inline FunctionSpec() : FunctionSpec(nullptr) {}
2210 ~FunctionSpec() override;
2211 explicit PROTOBUF_CONSTEXPR FunctionSpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2212
2213 FunctionSpec(const FunctionSpec& from);
FunctionSpec(FunctionSpec && from)2214 FunctionSpec(FunctionSpec&& from) noexcept
2215 : FunctionSpec() {
2216 *this = ::std::move(from);
2217 }
2218
2219 inline FunctionSpec& operator=(const FunctionSpec& from) {
2220 if (this == &from) return *this;
2221 CopyFrom(from);
2222 return *this;
2223 }
2224 inline FunctionSpec& operator=(FunctionSpec&& from) noexcept {
2225 if (this == &from) return *this;
2226 if (GetOwningArena() == from.GetOwningArena()
2227 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2228 && GetOwningArena() != nullptr
2229 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2230 ) {
2231 InternalSwap(&from);
2232 } else {
2233 CopyFrom(from);
2234 }
2235 return *this;
2236 }
2237
default_instance()2238 static const FunctionSpec& default_instance() {
2239 return *internal_default_instance();
2240 }
internal_default_instance()2241 static inline const FunctionSpec* internal_default_instance() {
2242 return reinterpret_cast<const FunctionSpec*>(
2243 &_FunctionSpec_default_instance_);
2244 }
2245 static constexpr int kIndexInFileMessages =
2246 12;
2247
swap(FunctionSpec & a,FunctionSpec & b)2248 friend void swap(FunctionSpec& a, FunctionSpec& b) {
2249 a.Swap(&b);
2250 }
Swap(FunctionSpec * other)2251 inline void Swap(FunctionSpec* other) {
2252 if (other == this) return;
2253 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2254 if (GetOwningArena() != nullptr &&
2255 GetOwningArena() == other->GetOwningArena()) {
2256 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2257 if (GetOwningArena() == other->GetOwningArena()) {
2258 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2259 InternalSwap(other);
2260 } else {
2261 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2262 }
2263 }
2264 void UnsafeArenaSwap(FunctionSpec* other) {
2265 if (other == this) return;
2266 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2267 InternalSwap(other);
2268 }
2269
2270 // implements Message ----------------------------------------------
2271
2272 FunctionSpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2273 return CreateMaybeMessage<FunctionSpec>(arena);
2274 }
2275 FunctionSpec* New() const {
2276 return New(nullptr);
2277 }
2278 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2279 void CopyFrom(const FunctionSpec& from);
2280 void MergeFrom(const FunctionSpec& from);
2281 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2282 bool IsInitialized() const final;
2283
2284 size_t ByteSizeLong() const final;
2285 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2286 ::uint8_t* _InternalSerialize(
2287 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2288 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2289
2290 private:
2291 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2292 void SharedDtor();
2293 void SetCachedSize(int size) const;
2294 void InternalSwap(FunctionSpec* other);
2295
2296 private:
2297 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2298 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2299 return "tensorflow.FunctionSpec";
2300 }
2301 protected:
2302 explicit FunctionSpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2303 bool is_message_owned = false);
2304 public:
2305
2306 std::string GetTypeName() const final;
2307
2308 // nested types ----------------------------------------------------
2309
2310 typedef FunctionSpec_JitCompile JitCompile;
2311 static constexpr JitCompile DEFAULT =
2312 FunctionSpec_JitCompile_DEFAULT;
2313 static constexpr JitCompile ON =
2314 FunctionSpec_JitCompile_ON;
2315 static constexpr JitCompile OFF =
2316 FunctionSpec_JitCompile_OFF;
2317 static inline bool JitCompile_IsValid(int value) {
2318 return FunctionSpec_JitCompile_IsValid(value);
2319 }
2320 static constexpr JitCompile JitCompile_MIN =
2321 FunctionSpec_JitCompile_JitCompile_MIN;
2322 static constexpr JitCompile JitCompile_MAX =
2323 FunctionSpec_JitCompile_JitCompile_MAX;
2324 static constexpr int JitCompile_ARRAYSIZE =
2325 FunctionSpec_JitCompile_JitCompile_ARRAYSIZE;
2326 template<typename T>
2327 static inline const std::string& JitCompile_Name(T enum_t_value) {
2328 static_assert(::std::is_same<T, JitCompile>::value ||
2329 ::std::is_integral<T>::value,
2330 "Incorrect type passed to function JitCompile_Name.");
2331 return FunctionSpec_JitCompile_Name(enum_t_value);
2332 }
2333 static inline bool JitCompile_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2334 JitCompile* value) {
2335 return FunctionSpec_JitCompile_Parse(name, value);
2336 }
2337
2338 // accessors -------------------------------------------------------
2339
2340 enum : int {
2341 kFullargspecFieldNumber = 1,
2342 kInputSignatureFieldNumber = 5,
2343 kIsMethodFieldNumber = 2,
2344 kJitCompileFieldNumber = 6,
2345 };
2346 // .tensorflow.StructuredValue fullargspec = 1;
2347 bool has_fullargspec() const;
2348 private:
2349 bool _internal_has_fullargspec() const;
2350 public:
2351 void clear_fullargspec();
2352 const ::tensorflow::StructuredValue& fullargspec() const;
2353 PROTOBUF_NODISCARD ::tensorflow::StructuredValue* release_fullargspec();
2354 ::tensorflow::StructuredValue* mutable_fullargspec();
2355 void set_allocated_fullargspec(::tensorflow::StructuredValue* fullargspec);
2356 private:
2357 const ::tensorflow::StructuredValue& _internal_fullargspec() const;
2358 ::tensorflow::StructuredValue* _internal_mutable_fullargspec();
2359 public:
2360 void unsafe_arena_set_allocated_fullargspec(
2361 ::tensorflow::StructuredValue* fullargspec);
2362 ::tensorflow::StructuredValue* unsafe_arena_release_fullargspec();
2363
2364 // .tensorflow.StructuredValue input_signature = 5;
2365 bool has_input_signature() const;
2366 private:
2367 bool _internal_has_input_signature() const;
2368 public:
2369 void clear_input_signature();
2370 const ::tensorflow::StructuredValue& input_signature() const;
2371 PROTOBUF_NODISCARD ::tensorflow::StructuredValue* release_input_signature();
2372 ::tensorflow::StructuredValue* mutable_input_signature();
2373 void set_allocated_input_signature(::tensorflow::StructuredValue* input_signature);
2374 private:
2375 const ::tensorflow::StructuredValue& _internal_input_signature() const;
2376 ::tensorflow::StructuredValue* _internal_mutable_input_signature();
2377 public:
2378 void unsafe_arena_set_allocated_input_signature(
2379 ::tensorflow::StructuredValue* input_signature);
2380 ::tensorflow::StructuredValue* unsafe_arena_release_input_signature();
2381
2382 // bool is_method = 2;
2383 void clear_is_method();
2384 bool is_method() const;
2385 void set_is_method(bool value);
2386 private:
2387 bool _internal_is_method() const;
2388 void _internal_set_is_method(bool value);
2389 public:
2390
2391 // .tensorflow.FunctionSpec.JitCompile jit_compile = 6;
2392 void clear_jit_compile();
2393 ::tensorflow::FunctionSpec_JitCompile jit_compile() const;
2394 void set_jit_compile(::tensorflow::FunctionSpec_JitCompile value);
2395 private:
2396 ::tensorflow::FunctionSpec_JitCompile _internal_jit_compile() const;
2397 void _internal_set_jit_compile(::tensorflow::FunctionSpec_JitCompile value);
2398 public:
2399
2400 // @@protoc_insertion_point(class_scope:tensorflow.FunctionSpec)
2401 private:
2402 class _Internal;
2403
2404 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2405 typedef void InternalArenaConstructable_;
2406 typedef void DestructorSkippable_;
2407 struct Impl_ {
2408 ::tensorflow::StructuredValue* fullargspec_;
2409 ::tensorflow::StructuredValue* input_signature_;
2410 bool is_method_;
2411 int jit_compile_;
2412 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2413 };
2414 union { Impl_ _impl_; };
2415 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
2416 };
2417 // -------------------------------------------------------------------
2418
2419 class SavedResource final :
2420 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SavedResource) */ {
2421 public:
SavedResource()2422 inline SavedResource() : SavedResource(nullptr) {}
2423 ~SavedResource() override;
2424 explicit PROTOBUF_CONSTEXPR SavedResource(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2425
2426 SavedResource(const SavedResource& from);
SavedResource(SavedResource && from)2427 SavedResource(SavedResource&& from) noexcept
2428 : SavedResource() {
2429 *this = ::std::move(from);
2430 }
2431
2432 inline SavedResource& operator=(const SavedResource& from) {
2433 if (this == &from) return *this;
2434 CopyFrom(from);
2435 return *this;
2436 }
2437 inline SavedResource& operator=(SavedResource&& from) noexcept {
2438 if (this == &from) return *this;
2439 if (GetOwningArena() == from.GetOwningArena()
2440 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2441 && GetOwningArena() != nullptr
2442 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2443 ) {
2444 InternalSwap(&from);
2445 } else {
2446 CopyFrom(from);
2447 }
2448 return *this;
2449 }
2450
default_instance()2451 static const SavedResource& default_instance() {
2452 return *internal_default_instance();
2453 }
internal_default_instance()2454 static inline const SavedResource* internal_default_instance() {
2455 return reinterpret_cast<const SavedResource*>(
2456 &_SavedResource_default_instance_);
2457 }
2458 static constexpr int kIndexInFileMessages =
2459 13;
2460
swap(SavedResource & a,SavedResource & b)2461 friend void swap(SavedResource& a, SavedResource& b) {
2462 a.Swap(&b);
2463 }
Swap(SavedResource * other)2464 inline void Swap(SavedResource* other) {
2465 if (other == this) return;
2466 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2467 if (GetOwningArena() != nullptr &&
2468 GetOwningArena() == other->GetOwningArena()) {
2469 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2470 if (GetOwningArena() == other->GetOwningArena()) {
2471 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2472 InternalSwap(other);
2473 } else {
2474 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2475 }
2476 }
2477 void UnsafeArenaSwap(SavedResource* other) {
2478 if (other == this) return;
2479 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2480 InternalSwap(other);
2481 }
2482
2483 // implements Message ----------------------------------------------
2484
2485 SavedResource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2486 return CreateMaybeMessage<SavedResource>(arena);
2487 }
2488 SavedResource* New() const {
2489 return New(nullptr);
2490 }
2491 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2492 void CopyFrom(const SavedResource& from);
2493 void MergeFrom(const SavedResource& from);
2494 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2495 bool IsInitialized() const final;
2496
2497 size_t ByteSizeLong() const final;
2498 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2499 ::uint8_t* _InternalSerialize(
2500 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2501 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2502
2503 private:
2504 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2505 void SharedDtor();
2506 void SetCachedSize(int size) const;
2507 void InternalSwap(SavedResource* other);
2508
2509 private:
2510 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2511 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2512 return "tensorflow.SavedResource";
2513 }
2514 protected:
2515 explicit SavedResource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2516 bool is_message_owned = false);
2517 public:
2518
2519 std::string GetTypeName() const final;
2520
2521 // nested types ----------------------------------------------------
2522
2523 // accessors -------------------------------------------------------
2524
2525 enum : int {
2526 kDeviceFieldNumber = 1,
2527 };
2528 // string device = 1;
2529 void clear_device();
2530 const std::string& device() const;
2531 template <typename ArgT0 = const std::string&, typename... ArgT>
2532 void set_device(ArgT0&& arg0, ArgT... args);
2533 std::string* mutable_device();
2534 PROTOBUF_NODISCARD std::string* release_device();
2535 void set_allocated_device(std::string* device);
2536 private:
2537 const std::string& _internal_device() const;
2538 inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
2539 std::string* _internal_mutable_device();
2540 public:
2541
2542 // @@protoc_insertion_point(class_scope:tensorflow.SavedResource)
2543 private:
2544 class _Internal;
2545
2546 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2547 typedef void InternalArenaConstructable_;
2548 typedef void DestructorSkippable_;
2549 struct Impl_ {
2550 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
2551 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2552 };
2553 union { Impl_ _impl_; };
2554 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
2555 };
2556 // -------------------------------------------------------------------
2557
2558 class SaveableObject final :
2559 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.SaveableObject) */ {
2560 public:
SaveableObject()2561 inline SaveableObject() : SaveableObject(nullptr) {}
2562 ~SaveableObject() override;
2563 explicit PROTOBUF_CONSTEXPR SaveableObject(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2564
2565 SaveableObject(const SaveableObject& from);
SaveableObject(SaveableObject && from)2566 SaveableObject(SaveableObject&& from) noexcept
2567 : SaveableObject() {
2568 *this = ::std::move(from);
2569 }
2570
2571 inline SaveableObject& operator=(const SaveableObject& from) {
2572 if (this == &from) return *this;
2573 CopyFrom(from);
2574 return *this;
2575 }
2576 inline SaveableObject& operator=(SaveableObject&& from) noexcept {
2577 if (this == &from) return *this;
2578 if (GetOwningArena() == from.GetOwningArena()
2579 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2580 && GetOwningArena() != nullptr
2581 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2582 ) {
2583 InternalSwap(&from);
2584 } else {
2585 CopyFrom(from);
2586 }
2587 return *this;
2588 }
2589
default_instance()2590 static const SaveableObject& default_instance() {
2591 return *internal_default_instance();
2592 }
internal_default_instance()2593 static inline const SaveableObject* internal_default_instance() {
2594 return reinterpret_cast<const SaveableObject*>(
2595 &_SaveableObject_default_instance_);
2596 }
2597 static constexpr int kIndexInFileMessages =
2598 14;
2599
swap(SaveableObject & a,SaveableObject & b)2600 friend void swap(SaveableObject& a, SaveableObject& b) {
2601 a.Swap(&b);
2602 }
Swap(SaveableObject * other)2603 inline void Swap(SaveableObject* other) {
2604 if (other == this) return;
2605 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2606 if (GetOwningArena() != nullptr &&
2607 GetOwningArena() == other->GetOwningArena()) {
2608 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2609 if (GetOwningArena() == other->GetOwningArena()) {
2610 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2611 InternalSwap(other);
2612 } else {
2613 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2614 }
2615 }
2616 void UnsafeArenaSwap(SaveableObject* other) {
2617 if (other == this) return;
2618 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2619 InternalSwap(other);
2620 }
2621
2622 // implements Message ----------------------------------------------
2623
2624 SaveableObject* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2625 return CreateMaybeMessage<SaveableObject>(arena);
2626 }
2627 SaveableObject* New() const {
2628 return New(nullptr);
2629 }
2630 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2631 void CopyFrom(const SaveableObject& from);
2632 void MergeFrom(const SaveableObject& from);
2633 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2634 bool IsInitialized() const final;
2635
2636 size_t ByteSizeLong() const final;
2637 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2638 ::uint8_t* _InternalSerialize(
2639 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2640 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2641
2642 private:
2643 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2644 void SharedDtor();
2645 void SetCachedSize(int size) const;
2646 void InternalSwap(SaveableObject* other);
2647
2648 private:
2649 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2650 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2651 return "tensorflow.SaveableObject";
2652 }
2653 protected:
2654 explicit SaveableObject(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2655 bool is_message_owned = false);
2656 public:
2657
2658 std::string GetTypeName() const final;
2659
2660 // nested types ----------------------------------------------------
2661
2662 // accessors -------------------------------------------------------
2663
2664 enum : int {
2665 kSaveFunctionFieldNumber = 2,
2666 kRestoreFunctionFieldNumber = 3,
2667 };
2668 // int32 save_function = 2;
2669 void clear_save_function();
2670 ::int32_t save_function() const;
2671 void set_save_function(::int32_t value);
2672 private:
2673 ::int32_t _internal_save_function() const;
2674 void _internal_set_save_function(::int32_t value);
2675 public:
2676
2677 // int32 restore_function = 3;
2678 void clear_restore_function();
2679 ::int32_t restore_function() const;
2680 void set_restore_function(::int32_t value);
2681 private:
2682 ::int32_t _internal_restore_function() const;
2683 void _internal_set_restore_function(::int32_t value);
2684 public:
2685
2686 // @@protoc_insertion_point(class_scope:tensorflow.SaveableObject)
2687 private:
2688 class _Internal;
2689
2690 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2691 typedef void InternalArenaConstructable_;
2692 typedef void DestructorSkippable_;
2693 struct Impl_ {
2694 ::int32_t save_function_;
2695 ::int32_t restore_function_;
2696 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2697 };
2698 union { Impl_ _impl_; };
2699 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fsaved_5fobject_5fgraph_2eproto;
2700 };
2701 // ===================================================================
2702
2703
2704 // ===================================================================
2705
2706 #ifdef __GNUC__
2707 #pragma GCC diagnostic push
2708 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2709 #endif // __GNUC__
2710 // -------------------------------------------------------------------
2711
2712 // SavedObjectGraph
2713
2714 // repeated .tensorflow.SavedObject nodes = 1;
_internal_nodes_size()2715 inline int SavedObjectGraph::_internal_nodes_size() const {
2716 return _impl_.nodes_.size();
2717 }
nodes_size()2718 inline int SavedObjectGraph::nodes_size() const {
2719 return _internal_nodes_size();
2720 }
clear_nodes()2721 inline void SavedObjectGraph::clear_nodes() {
2722 _impl_.nodes_.Clear();
2723 }
mutable_nodes(int index)2724 inline ::tensorflow::SavedObject* SavedObjectGraph::mutable_nodes(int index) {
2725 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObjectGraph.nodes)
2726 return _impl_.nodes_.Mutable(index);
2727 }
2728 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedObject >*
mutable_nodes()2729 SavedObjectGraph::mutable_nodes() {
2730 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedObjectGraph.nodes)
2731 return &_impl_.nodes_;
2732 }
_internal_nodes(int index)2733 inline const ::tensorflow::SavedObject& SavedObjectGraph::_internal_nodes(int index) const {
2734 return _impl_.nodes_.Get(index);
2735 }
nodes(int index)2736 inline const ::tensorflow::SavedObject& SavedObjectGraph::nodes(int index) const {
2737 // @@protoc_insertion_point(field_get:tensorflow.SavedObjectGraph.nodes)
2738 return _internal_nodes(index);
2739 }
_internal_add_nodes()2740 inline ::tensorflow::SavedObject* SavedObjectGraph::_internal_add_nodes() {
2741 return _impl_.nodes_.Add();
2742 }
add_nodes()2743 inline ::tensorflow::SavedObject* SavedObjectGraph::add_nodes() {
2744 ::tensorflow::SavedObject* _add = _internal_add_nodes();
2745 // @@protoc_insertion_point(field_add:tensorflow.SavedObjectGraph.nodes)
2746 return _add;
2747 }
2748 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::SavedObject >&
nodes()2749 SavedObjectGraph::nodes() const {
2750 // @@protoc_insertion_point(field_list:tensorflow.SavedObjectGraph.nodes)
2751 return _impl_.nodes_;
2752 }
2753
2754 // map<string, .tensorflow.SavedConcreteFunction> concrete_functions = 2;
_internal_concrete_functions_size()2755 inline int SavedObjectGraph::_internal_concrete_functions_size() const {
2756 return _impl_.concrete_functions_.size();
2757 }
concrete_functions_size()2758 inline int SavedObjectGraph::concrete_functions_size() const {
2759 return _internal_concrete_functions_size();
2760 }
clear_concrete_functions()2761 inline void SavedObjectGraph::clear_concrete_functions() {
2762 _impl_.concrete_functions_.Clear();
2763 }
2764 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >&
_internal_concrete_functions()2765 SavedObjectGraph::_internal_concrete_functions() const {
2766 return _impl_.concrete_functions_.GetMap();
2767 }
2768 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >&
concrete_functions()2769 SavedObjectGraph::concrete_functions() const {
2770 // @@protoc_insertion_point(field_map:tensorflow.SavedObjectGraph.concrete_functions)
2771 return _internal_concrete_functions();
2772 }
2773 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >*
_internal_mutable_concrete_functions()2774 SavedObjectGraph::_internal_mutable_concrete_functions() {
2775 return _impl_.concrete_functions_.MutableMap();
2776 }
2777 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SavedConcreteFunction >*
mutable_concrete_functions()2778 SavedObjectGraph::mutable_concrete_functions() {
2779 // @@protoc_insertion_point(field_mutable_map:tensorflow.SavedObjectGraph.concrete_functions)
2780 return _internal_mutable_concrete_functions();
2781 }
2782
2783 // -------------------------------------------------------------------
2784
2785 // -------------------------------------------------------------------
2786
2787 // SavedObject
2788
2789 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference children = 1;
_internal_children_size()2790 inline int SavedObject::_internal_children_size() const {
2791 return _impl_.children_.size();
2792 }
children_size()2793 inline int SavedObject::children_size() const {
2794 return _internal_children_size();
2795 }
mutable_children(int index)2796 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::mutable_children(int index) {
2797 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.children)
2798 return _impl_.children_.Mutable(index);
2799 }
2800 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
mutable_children()2801 SavedObject::mutable_children() {
2802 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedObject.children)
2803 return &_impl_.children_;
2804 }
_internal_children(int index)2805 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& SavedObject::_internal_children(int index) const {
2806 return _impl_.children_.Get(index);
2807 }
children(int index)2808 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& SavedObject::children(int index) const {
2809 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.children)
2810 return _internal_children(index);
2811 }
_internal_add_children()2812 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::_internal_add_children() {
2813 return _impl_.children_.Add();
2814 }
add_children()2815 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::add_children() {
2816 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _add = _internal_add_children();
2817 // @@protoc_insertion_point(field_add:tensorflow.SavedObject.children)
2818 return _add;
2819 }
2820 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
children()2821 SavedObject::children() const {
2822 // @@protoc_insertion_point(field_list:tensorflow.SavedObject.children)
2823 return _impl_.children_;
2824 }
2825
2826 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.ObjectReference dependencies = 15;
_internal_dependencies_size()2827 inline int SavedObject::_internal_dependencies_size() const {
2828 return _impl_.dependencies_.size();
2829 }
dependencies_size()2830 inline int SavedObject::dependencies_size() const {
2831 return _internal_dependencies_size();
2832 }
mutable_dependencies(int index)2833 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::mutable_dependencies(int index) {
2834 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.dependencies)
2835 return _impl_.dependencies_.Mutable(index);
2836 }
2837 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >*
mutable_dependencies()2838 SavedObject::mutable_dependencies() {
2839 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedObject.dependencies)
2840 return &_impl_.dependencies_;
2841 }
_internal_dependencies(int index)2842 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& SavedObject::_internal_dependencies(int index) const {
2843 return _impl_.dependencies_.Get(index);
2844 }
dependencies(int index)2845 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference& SavedObject::dependencies(int index) const {
2846 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.dependencies)
2847 return _internal_dependencies(index);
2848 }
_internal_add_dependencies()2849 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::_internal_add_dependencies() {
2850 return _impl_.dependencies_.Add();
2851 }
add_dependencies()2852 inline ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* SavedObject::add_dependencies() {
2853 ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference* _add = _internal_add_dependencies();
2854 // @@protoc_insertion_point(field_add:tensorflow.SavedObject.dependencies)
2855 return _add;
2856 }
2857 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_ObjectReference >&
dependencies()2858 SavedObject::dependencies() const {
2859 // @@protoc_insertion_point(field_list:tensorflow.SavedObject.dependencies)
2860 return _impl_.dependencies_;
2861 }
2862
2863 // repeated .tensorflow.TrackableObjectGraph.TrackableObject.SlotVariableReference slot_variables = 3;
_internal_slot_variables_size()2864 inline int SavedObject::_internal_slot_variables_size() const {
2865 return _impl_.slot_variables_.size();
2866 }
slot_variables_size()2867 inline int SavedObject::slot_variables_size() const {
2868 return _internal_slot_variables_size();
2869 }
mutable_slot_variables(int index)2870 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* SavedObject::mutable_slot_variables(int index) {
2871 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.slot_variables)
2872 return _impl_.slot_variables_.Mutable(index);
2873 }
2874 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >*
mutable_slot_variables()2875 SavedObject::mutable_slot_variables() {
2876 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedObject.slot_variables)
2877 return &_impl_.slot_variables_;
2878 }
_internal_slot_variables(int index)2879 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& SavedObject::_internal_slot_variables(int index) const {
2880 return _impl_.slot_variables_.Get(index);
2881 }
slot_variables(int index)2882 inline const ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference& SavedObject::slot_variables(int index) const {
2883 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.slot_variables)
2884 return _internal_slot_variables(index);
2885 }
_internal_add_slot_variables()2886 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* SavedObject::_internal_add_slot_variables() {
2887 return _impl_.slot_variables_.Add();
2888 }
add_slot_variables()2889 inline ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* SavedObject::add_slot_variables() {
2890 ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference* _add = _internal_add_slot_variables();
2891 // @@protoc_insertion_point(field_add:tensorflow.SavedObject.slot_variables)
2892 return _add;
2893 }
2894 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TrackableObjectGraph_TrackableObject_SlotVariableReference >&
slot_variables()2895 SavedObject::slot_variables() const {
2896 // @@protoc_insertion_point(field_list:tensorflow.SavedObject.slot_variables)
2897 return _impl_.slot_variables_;
2898 }
2899
2900 // .tensorflow.SavedUserObject user_object = 4;
_internal_has_user_object()2901 inline bool SavedObject::_internal_has_user_object() const {
2902 return kind_case() == kUserObject;
2903 }
has_user_object()2904 inline bool SavedObject::has_user_object() const {
2905 return _internal_has_user_object();
2906 }
set_has_user_object()2907 inline void SavedObject::set_has_user_object() {
2908 _impl_._oneof_case_[0] = kUserObject;
2909 }
clear_user_object()2910 inline void SavedObject::clear_user_object() {
2911 if (_internal_has_user_object()) {
2912 if (GetArenaForAllocation() == nullptr) {
2913 delete _impl_.kind_.user_object_;
2914 }
2915 clear_has_kind();
2916 }
2917 }
release_user_object()2918 inline ::tensorflow::SavedUserObject* SavedObject::release_user_object() {
2919 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.user_object)
2920 if (_internal_has_user_object()) {
2921 clear_has_kind();
2922 ::tensorflow::SavedUserObject* temp = _impl_.kind_.user_object_;
2923 if (GetArenaForAllocation() != nullptr) {
2924 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2925 }
2926 _impl_.kind_.user_object_ = nullptr;
2927 return temp;
2928 } else {
2929 return nullptr;
2930 }
2931 }
_internal_user_object()2932 inline const ::tensorflow::SavedUserObject& SavedObject::_internal_user_object() const {
2933 return _internal_has_user_object()
2934 ? *_impl_.kind_.user_object_
2935 : reinterpret_cast< ::tensorflow::SavedUserObject&>(::tensorflow::_SavedUserObject_default_instance_);
2936 }
user_object()2937 inline const ::tensorflow::SavedUserObject& SavedObject::user_object() const {
2938 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.user_object)
2939 return _internal_user_object();
2940 }
unsafe_arena_release_user_object()2941 inline ::tensorflow::SavedUserObject* SavedObject::unsafe_arena_release_user_object() {
2942 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.user_object)
2943 if (_internal_has_user_object()) {
2944 clear_has_kind();
2945 ::tensorflow::SavedUserObject* temp = _impl_.kind_.user_object_;
2946 _impl_.kind_.user_object_ = nullptr;
2947 return temp;
2948 } else {
2949 return nullptr;
2950 }
2951 }
unsafe_arena_set_allocated_user_object(::tensorflow::SavedUserObject * user_object)2952 inline void SavedObject::unsafe_arena_set_allocated_user_object(::tensorflow::SavedUserObject* user_object) {
2953 clear_kind();
2954 if (user_object) {
2955 set_has_user_object();
2956 _impl_.kind_.user_object_ = user_object;
2957 }
2958 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.user_object)
2959 }
_internal_mutable_user_object()2960 inline ::tensorflow::SavedUserObject* SavedObject::_internal_mutable_user_object() {
2961 if (!_internal_has_user_object()) {
2962 clear_kind();
2963 set_has_user_object();
2964 _impl_.kind_.user_object_ = CreateMaybeMessage< ::tensorflow::SavedUserObject >(GetArenaForAllocation());
2965 }
2966 return _impl_.kind_.user_object_;
2967 }
mutable_user_object()2968 inline ::tensorflow::SavedUserObject* SavedObject::mutable_user_object() {
2969 ::tensorflow::SavedUserObject* _msg = _internal_mutable_user_object();
2970 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.user_object)
2971 return _msg;
2972 }
2973
2974 // .tensorflow.SavedAsset asset = 5;
_internal_has_asset()2975 inline bool SavedObject::_internal_has_asset() const {
2976 return kind_case() == kAsset;
2977 }
has_asset()2978 inline bool SavedObject::has_asset() const {
2979 return _internal_has_asset();
2980 }
set_has_asset()2981 inline void SavedObject::set_has_asset() {
2982 _impl_._oneof_case_[0] = kAsset;
2983 }
clear_asset()2984 inline void SavedObject::clear_asset() {
2985 if (_internal_has_asset()) {
2986 if (GetArenaForAllocation() == nullptr) {
2987 delete _impl_.kind_.asset_;
2988 }
2989 clear_has_kind();
2990 }
2991 }
release_asset()2992 inline ::tensorflow::SavedAsset* SavedObject::release_asset() {
2993 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.asset)
2994 if (_internal_has_asset()) {
2995 clear_has_kind();
2996 ::tensorflow::SavedAsset* temp = _impl_.kind_.asset_;
2997 if (GetArenaForAllocation() != nullptr) {
2998 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2999 }
3000 _impl_.kind_.asset_ = nullptr;
3001 return temp;
3002 } else {
3003 return nullptr;
3004 }
3005 }
_internal_asset()3006 inline const ::tensorflow::SavedAsset& SavedObject::_internal_asset() const {
3007 return _internal_has_asset()
3008 ? *_impl_.kind_.asset_
3009 : reinterpret_cast< ::tensorflow::SavedAsset&>(::tensorflow::_SavedAsset_default_instance_);
3010 }
asset()3011 inline const ::tensorflow::SavedAsset& SavedObject::asset() const {
3012 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.asset)
3013 return _internal_asset();
3014 }
unsafe_arena_release_asset()3015 inline ::tensorflow::SavedAsset* SavedObject::unsafe_arena_release_asset() {
3016 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.asset)
3017 if (_internal_has_asset()) {
3018 clear_has_kind();
3019 ::tensorflow::SavedAsset* temp = _impl_.kind_.asset_;
3020 _impl_.kind_.asset_ = nullptr;
3021 return temp;
3022 } else {
3023 return nullptr;
3024 }
3025 }
unsafe_arena_set_allocated_asset(::tensorflow::SavedAsset * asset)3026 inline void SavedObject::unsafe_arena_set_allocated_asset(::tensorflow::SavedAsset* asset) {
3027 clear_kind();
3028 if (asset) {
3029 set_has_asset();
3030 _impl_.kind_.asset_ = asset;
3031 }
3032 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.asset)
3033 }
_internal_mutable_asset()3034 inline ::tensorflow::SavedAsset* SavedObject::_internal_mutable_asset() {
3035 if (!_internal_has_asset()) {
3036 clear_kind();
3037 set_has_asset();
3038 _impl_.kind_.asset_ = CreateMaybeMessage< ::tensorflow::SavedAsset >(GetArenaForAllocation());
3039 }
3040 return _impl_.kind_.asset_;
3041 }
mutable_asset()3042 inline ::tensorflow::SavedAsset* SavedObject::mutable_asset() {
3043 ::tensorflow::SavedAsset* _msg = _internal_mutable_asset();
3044 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.asset)
3045 return _msg;
3046 }
3047
3048 // .tensorflow.SavedFunction function = 6;
_internal_has_function()3049 inline bool SavedObject::_internal_has_function() const {
3050 return kind_case() == kFunction;
3051 }
has_function()3052 inline bool SavedObject::has_function() const {
3053 return _internal_has_function();
3054 }
set_has_function()3055 inline void SavedObject::set_has_function() {
3056 _impl_._oneof_case_[0] = kFunction;
3057 }
clear_function()3058 inline void SavedObject::clear_function() {
3059 if (_internal_has_function()) {
3060 if (GetArenaForAllocation() == nullptr) {
3061 delete _impl_.kind_.function_;
3062 }
3063 clear_has_kind();
3064 }
3065 }
release_function()3066 inline ::tensorflow::SavedFunction* SavedObject::release_function() {
3067 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.function)
3068 if (_internal_has_function()) {
3069 clear_has_kind();
3070 ::tensorflow::SavedFunction* temp = _impl_.kind_.function_;
3071 if (GetArenaForAllocation() != nullptr) {
3072 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3073 }
3074 _impl_.kind_.function_ = nullptr;
3075 return temp;
3076 } else {
3077 return nullptr;
3078 }
3079 }
_internal_function()3080 inline const ::tensorflow::SavedFunction& SavedObject::_internal_function() const {
3081 return _internal_has_function()
3082 ? *_impl_.kind_.function_
3083 : reinterpret_cast< ::tensorflow::SavedFunction&>(::tensorflow::_SavedFunction_default_instance_);
3084 }
function()3085 inline const ::tensorflow::SavedFunction& SavedObject::function() const {
3086 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.function)
3087 return _internal_function();
3088 }
unsafe_arena_release_function()3089 inline ::tensorflow::SavedFunction* SavedObject::unsafe_arena_release_function() {
3090 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.function)
3091 if (_internal_has_function()) {
3092 clear_has_kind();
3093 ::tensorflow::SavedFunction* temp = _impl_.kind_.function_;
3094 _impl_.kind_.function_ = nullptr;
3095 return temp;
3096 } else {
3097 return nullptr;
3098 }
3099 }
unsafe_arena_set_allocated_function(::tensorflow::SavedFunction * function)3100 inline void SavedObject::unsafe_arena_set_allocated_function(::tensorflow::SavedFunction* function) {
3101 clear_kind();
3102 if (function) {
3103 set_has_function();
3104 _impl_.kind_.function_ = function;
3105 }
3106 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.function)
3107 }
_internal_mutable_function()3108 inline ::tensorflow::SavedFunction* SavedObject::_internal_mutable_function() {
3109 if (!_internal_has_function()) {
3110 clear_kind();
3111 set_has_function();
3112 _impl_.kind_.function_ = CreateMaybeMessage< ::tensorflow::SavedFunction >(GetArenaForAllocation());
3113 }
3114 return _impl_.kind_.function_;
3115 }
mutable_function()3116 inline ::tensorflow::SavedFunction* SavedObject::mutable_function() {
3117 ::tensorflow::SavedFunction* _msg = _internal_mutable_function();
3118 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.function)
3119 return _msg;
3120 }
3121
3122 // .tensorflow.SavedVariable variable = 7;
_internal_has_variable()3123 inline bool SavedObject::_internal_has_variable() const {
3124 return kind_case() == kVariable;
3125 }
has_variable()3126 inline bool SavedObject::has_variable() const {
3127 return _internal_has_variable();
3128 }
set_has_variable()3129 inline void SavedObject::set_has_variable() {
3130 _impl_._oneof_case_[0] = kVariable;
3131 }
clear_variable()3132 inline void SavedObject::clear_variable() {
3133 if (_internal_has_variable()) {
3134 if (GetArenaForAllocation() == nullptr) {
3135 delete _impl_.kind_.variable_;
3136 }
3137 clear_has_kind();
3138 }
3139 }
release_variable()3140 inline ::tensorflow::SavedVariable* SavedObject::release_variable() {
3141 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.variable)
3142 if (_internal_has_variable()) {
3143 clear_has_kind();
3144 ::tensorflow::SavedVariable* temp = _impl_.kind_.variable_;
3145 if (GetArenaForAllocation() != nullptr) {
3146 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3147 }
3148 _impl_.kind_.variable_ = nullptr;
3149 return temp;
3150 } else {
3151 return nullptr;
3152 }
3153 }
_internal_variable()3154 inline const ::tensorflow::SavedVariable& SavedObject::_internal_variable() const {
3155 return _internal_has_variable()
3156 ? *_impl_.kind_.variable_
3157 : reinterpret_cast< ::tensorflow::SavedVariable&>(::tensorflow::_SavedVariable_default_instance_);
3158 }
variable()3159 inline const ::tensorflow::SavedVariable& SavedObject::variable() const {
3160 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.variable)
3161 return _internal_variable();
3162 }
unsafe_arena_release_variable()3163 inline ::tensorflow::SavedVariable* SavedObject::unsafe_arena_release_variable() {
3164 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.variable)
3165 if (_internal_has_variable()) {
3166 clear_has_kind();
3167 ::tensorflow::SavedVariable* temp = _impl_.kind_.variable_;
3168 _impl_.kind_.variable_ = nullptr;
3169 return temp;
3170 } else {
3171 return nullptr;
3172 }
3173 }
unsafe_arena_set_allocated_variable(::tensorflow::SavedVariable * variable)3174 inline void SavedObject::unsafe_arena_set_allocated_variable(::tensorflow::SavedVariable* variable) {
3175 clear_kind();
3176 if (variable) {
3177 set_has_variable();
3178 _impl_.kind_.variable_ = variable;
3179 }
3180 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.variable)
3181 }
_internal_mutable_variable()3182 inline ::tensorflow::SavedVariable* SavedObject::_internal_mutable_variable() {
3183 if (!_internal_has_variable()) {
3184 clear_kind();
3185 set_has_variable();
3186 _impl_.kind_.variable_ = CreateMaybeMessage< ::tensorflow::SavedVariable >(GetArenaForAllocation());
3187 }
3188 return _impl_.kind_.variable_;
3189 }
mutable_variable()3190 inline ::tensorflow::SavedVariable* SavedObject::mutable_variable() {
3191 ::tensorflow::SavedVariable* _msg = _internal_mutable_variable();
3192 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.variable)
3193 return _msg;
3194 }
3195
3196 // .tensorflow.SavedBareConcreteFunction bare_concrete_function = 8;
_internal_has_bare_concrete_function()3197 inline bool SavedObject::_internal_has_bare_concrete_function() const {
3198 return kind_case() == kBareConcreteFunction;
3199 }
has_bare_concrete_function()3200 inline bool SavedObject::has_bare_concrete_function() const {
3201 return _internal_has_bare_concrete_function();
3202 }
set_has_bare_concrete_function()3203 inline void SavedObject::set_has_bare_concrete_function() {
3204 _impl_._oneof_case_[0] = kBareConcreteFunction;
3205 }
clear_bare_concrete_function()3206 inline void SavedObject::clear_bare_concrete_function() {
3207 if (_internal_has_bare_concrete_function()) {
3208 if (GetArenaForAllocation() == nullptr) {
3209 delete _impl_.kind_.bare_concrete_function_;
3210 }
3211 clear_has_kind();
3212 }
3213 }
release_bare_concrete_function()3214 inline ::tensorflow::SavedBareConcreteFunction* SavedObject::release_bare_concrete_function() {
3215 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.bare_concrete_function)
3216 if (_internal_has_bare_concrete_function()) {
3217 clear_has_kind();
3218 ::tensorflow::SavedBareConcreteFunction* temp = _impl_.kind_.bare_concrete_function_;
3219 if (GetArenaForAllocation() != nullptr) {
3220 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3221 }
3222 _impl_.kind_.bare_concrete_function_ = nullptr;
3223 return temp;
3224 } else {
3225 return nullptr;
3226 }
3227 }
_internal_bare_concrete_function()3228 inline const ::tensorflow::SavedBareConcreteFunction& SavedObject::_internal_bare_concrete_function() const {
3229 return _internal_has_bare_concrete_function()
3230 ? *_impl_.kind_.bare_concrete_function_
3231 : reinterpret_cast< ::tensorflow::SavedBareConcreteFunction&>(::tensorflow::_SavedBareConcreteFunction_default_instance_);
3232 }
bare_concrete_function()3233 inline const ::tensorflow::SavedBareConcreteFunction& SavedObject::bare_concrete_function() const {
3234 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.bare_concrete_function)
3235 return _internal_bare_concrete_function();
3236 }
unsafe_arena_release_bare_concrete_function()3237 inline ::tensorflow::SavedBareConcreteFunction* SavedObject::unsafe_arena_release_bare_concrete_function() {
3238 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.bare_concrete_function)
3239 if (_internal_has_bare_concrete_function()) {
3240 clear_has_kind();
3241 ::tensorflow::SavedBareConcreteFunction* temp = _impl_.kind_.bare_concrete_function_;
3242 _impl_.kind_.bare_concrete_function_ = nullptr;
3243 return temp;
3244 } else {
3245 return nullptr;
3246 }
3247 }
unsafe_arena_set_allocated_bare_concrete_function(::tensorflow::SavedBareConcreteFunction * bare_concrete_function)3248 inline void SavedObject::unsafe_arena_set_allocated_bare_concrete_function(::tensorflow::SavedBareConcreteFunction* bare_concrete_function) {
3249 clear_kind();
3250 if (bare_concrete_function) {
3251 set_has_bare_concrete_function();
3252 _impl_.kind_.bare_concrete_function_ = bare_concrete_function;
3253 }
3254 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.bare_concrete_function)
3255 }
_internal_mutable_bare_concrete_function()3256 inline ::tensorflow::SavedBareConcreteFunction* SavedObject::_internal_mutable_bare_concrete_function() {
3257 if (!_internal_has_bare_concrete_function()) {
3258 clear_kind();
3259 set_has_bare_concrete_function();
3260 _impl_.kind_.bare_concrete_function_ = CreateMaybeMessage< ::tensorflow::SavedBareConcreteFunction >(GetArenaForAllocation());
3261 }
3262 return _impl_.kind_.bare_concrete_function_;
3263 }
mutable_bare_concrete_function()3264 inline ::tensorflow::SavedBareConcreteFunction* SavedObject::mutable_bare_concrete_function() {
3265 ::tensorflow::SavedBareConcreteFunction* _msg = _internal_mutable_bare_concrete_function();
3266 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.bare_concrete_function)
3267 return _msg;
3268 }
3269
3270 // .tensorflow.SavedConstant constant = 9;
_internal_has_constant()3271 inline bool SavedObject::_internal_has_constant() const {
3272 return kind_case() == kConstant;
3273 }
has_constant()3274 inline bool SavedObject::has_constant() const {
3275 return _internal_has_constant();
3276 }
set_has_constant()3277 inline void SavedObject::set_has_constant() {
3278 _impl_._oneof_case_[0] = kConstant;
3279 }
clear_constant()3280 inline void SavedObject::clear_constant() {
3281 if (_internal_has_constant()) {
3282 if (GetArenaForAllocation() == nullptr) {
3283 delete _impl_.kind_.constant_;
3284 }
3285 clear_has_kind();
3286 }
3287 }
release_constant()3288 inline ::tensorflow::SavedConstant* SavedObject::release_constant() {
3289 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.constant)
3290 if (_internal_has_constant()) {
3291 clear_has_kind();
3292 ::tensorflow::SavedConstant* temp = _impl_.kind_.constant_;
3293 if (GetArenaForAllocation() != nullptr) {
3294 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3295 }
3296 _impl_.kind_.constant_ = nullptr;
3297 return temp;
3298 } else {
3299 return nullptr;
3300 }
3301 }
_internal_constant()3302 inline const ::tensorflow::SavedConstant& SavedObject::_internal_constant() const {
3303 return _internal_has_constant()
3304 ? *_impl_.kind_.constant_
3305 : reinterpret_cast< ::tensorflow::SavedConstant&>(::tensorflow::_SavedConstant_default_instance_);
3306 }
constant()3307 inline const ::tensorflow::SavedConstant& SavedObject::constant() const {
3308 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.constant)
3309 return _internal_constant();
3310 }
unsafe_arena_release_constant()3311 inline ::tensorflow::SavedConstant* SavedObject::unsafe_arena_release_constant() {
3312 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.constant)
3313 if (_internal_has_constant()) {
3314 clear_has_kind();
3315 ::tensorflow::SavedConstant* temp = _impl_.kind_.constant_;
3316 _impl_.kind_.constant_ = nullptr;
3317 return temp;
3318 } else {
3319 return nullptr;
3320 }
3321 }
unsafe_arena_set_allocated_constant(::tensorflow::SavedConstant * constant)3322 inline void SavedObject::unsafe_arena_set_allocated_constant(::tensorflow::SavedConstant* constant) {
3323 clear_kind();
3324 if (constant) {
3325 set_has_constant();
3326 _impl_.kind_.constant_ = constant;
3327 }
3328 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.constant)
3329 }
_internal_mutable_constant()3330 inline ::tensorflow::SavedConstant* SavedObject::_internal_mutable_constant() {
3331 if (!_internal_has_constant()) {
3332 clear_kind();
3333 set_has_constant();
3334 _impl_.kind_.constant_ = CreateMaybeMessage< ::tensorflow::SavedConstant >(GetArenaForAllocation());
3335 }
3336 return _impl_.kind_.constant_;
3337 }
mutable_constant()3338 inline ::tensorflow::SavedConstant* SavedObject::mutable_constant() {
3339 ::tensorflow::SavedConstant* _msg = _internal_mutable_constant();
3340 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.constant)
3341 return _msg;
3342 }
3343
3344 // .tensorflow.SavedResource resource = 10;
_internal_has_resource()3345 inline bool SavedObject::_internal_has_resource() const {
3346 return kind_case() == kResource;
3347 }
has_resource()3348 inline bool SavedObject::has_resource() const {
3349 return _internal_has_resource();
3350 }
set_has_resource()3351 inline void SavedObject::set_has_resource() {
3352 _impl_._oneof_case_[0] = kResource;
3353 }
clear_resource()3354 inline void SavedObject::clear_resource() {
3355 if (_internal_has_resource()) {
3356 if (GetArenaForAllocation() == nullptr) {
3357 delete _impl_.kind_.resource_;
3358 }
3359 clear_has_kind();
3360 }
3361 }
release_resource()3362 inline ::tensorflow::SavedResource* SavedObject::release_resource() {
3363 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.resource)
3364 if (_internal_has_resource()) {
3365 clear_has_kind();
3366 ::tensorflow::SavedResource* temp = _impl_.kind_.resource_;
3367 if (GetArenaForAllocation() != nullptr) {
3368 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3369 }
3370 _impl_.kind_.resource_ = nullptr;
3371 return temp;
3372 } else {
3373 return nullptr;
3374 }
3375 }
_internal_resource()3376 inline const ::tensorflow::SavedResource& SavedObject::_internal_resource() const {
3377 return _internal_has_resource()
3378 ? *_impl_.kind_.resource_
3379 : reinterpret_cast< ::tensorflow::SavedResource&>(::tensorflow::_SavedResource_default_instance_);
3380 }
resource()3381 inline const ::tensorflow::SavedResource& SavedObject::resource() const {
3382 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.resource)
3383 return _internal_resource();
3384 }
unsafe_arena_release_resource()3385 inline ::tensorflow::SavedResource* SavedObject::unsafe_arena_release_resource() {
3386 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.resource)
3387 if (_internal_has_resource()) {
3388 clear_has_kind();
3389 ::tensorflow::SavedResource* temp = _impl_.kind_.resource_;
3390 _impl_.kind_.resource_ = nullptr;
3391 return temp;
3392 } else {
3393 return nullptr;
3394 }
3395 }
unsafe_arena_set_allocated_resource(::tensorflow::SavedResource * resource)3396 inline void SavedObject::unsafe_arena_set_allocated_resource(::tensorflow::SavedResource* resource) {
3397 clear_kind();
3398 if (resource) {
3399 set_has_resource();
3400 _impl_.kind_.resource_ = resource;
3401 }
3402 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.resource)
3403 }
_internal_mutable_resource()3404 inline ::tensorflow::SavedResource* SavedObject::_internal_mutable_resource() {
3405 if (!_internal_has_resource()) {
3406 clear_kind();
3407 set_has_resource();
3408 _impl_.kind_.resource_ = CreateMaybeMessage< ::tensorflow::SavedResource >(GetArenaForAllocation());
3409 }
3410 return _impl_.kind_.resource_;
3411 }
mutable_resource()3412 inline ::tensorflow::SavedResource* SavedObject::mutable_resource() {
3413 ::tensorflow::SavedResource* _msg = _internal_mutable_resource();
3414 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.resource)
3415 return _msg;
3416 }
3417
3418 // .tensorflow.CapturedTensor captured_tensor = 12;
_internal_has_captured_tensor()3419 inline bool SavedObject::_internal_has_captured_tensor() const {
3420 return kind_case() == kCapturedTensor;
3421 }
has_captured_tensor()3422 inline bool SavedObject::has_captured_tensor() const {
3423 return _internal_has_captured_tensor();
3424 }
set_has_captured_tensor()3425 inline void SavedObject::set_has_captured_tensor() {
3426 _impl_._oneof_case_[0] = kCapturedTensor;
3427 }
clear_captured_tensor()3428 inline void SavedObject::clear_captured_tensor() {
3429 if (_internal_has_captured_tensor()) {
3430 if (GetArenaForAllocation() == nullptr) {
3431 delete _impl_.kind_.captured_tensor_;
3432 }
3433 clear_has_kind();
3434 }
3435 }
release_captured_tensor()3436 inline ::tensorflow::CapturedTensor* SavedObject::release_captured_tensor() {
3437 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.captured_tensor)
3438 if (_internal_has_captured_tensor()) {
3439 clear_has_kind();
3440 ::tensorflow::CapturedTensor* temp = _impl_.kind_.captured_tensor_;
3441 if (GetArenaForAllocation() != nullptr) {
3442 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3443 }
3444 _impl_.kind_.captured_tensor_ = nullptr;
3445 return temp;
3446 } else {
3447 return nullptr;
3448 }
3449 }
_internal_captured_tensor()3450 inline const ::tensorflow::CapturedTensor& SavedObject::_internal_captured_tensor() const {
3451 return _internal_has_captured_tensor()
3452 ? *_impl_.kind_.captured_tensor_
3453 : reinterpret_cast< ::tensorflow::CapturedTensor&>(::tensorflow::_CapturedTensor_default_instance_);
3454 }
captured_tensor()3455 inline const ::tensorflow::CapturedTensor& SavedObject::captured_tensor() const {
3456 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.captured_tensor)
3457 return _internal_captured_tensor();
3458 }
unsafe_arena_release_captured_tensor()3459 inline ::tensorflow::CapturedTensor* SavedObject::unsafe_arena_release_captured_tensor() {
3460 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SavedObject.captured_tensor)
3461 if (_internal_has_captured_tensor()) {
3462 clear_has_kind();
3463 ::tensorflow::CapturedTensor* temp = _impl_.kind_.captured_tensor_;
3464 _impl_.kind_.captured_tensor_ = nullptr;
3465 return temp;
3466 } else {
3467 return nullptr;
3468 }
3469 }
unsafe_arena_set_allocated_captured_tensor(::tensorflow::CapturedTensor * captured_tensor)3470 inline void SavedObject::unsafe_arena_set_allocated_captured_tensor(::tensorflow::CapturedTensor* captured_tensor) {
3471 clear_kind();
3472 if (captured_tensor) {
3473 set_has_captured_tensor();
3474 _impl_.kind_.captured_tensor_ = captured_tensor;
3475 }
3476 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.captured_tensor)
3477 }
_internal_mutable_captured_tensor()3478 inline ::tensorflow::CapturedTensor* SavedObject::_internal_mutable_captured_tensor() {
3479 if (!_internal_has_captured_tensor()) {
3480 clear_kind();
3481 set_has_captured_tensor();
3482 _impl_.kind_.captured_tensor_ = CreateMaybeMessage< ::tensorflow::CapturedTensor >(GetArenaForAllocation());
3483 }
3484 return _impl_.kind_.captured_tensor_;
3485 }
mutable_captured_tensor()3486 inline ::tensorflow::CapturedTensor* SavedObject::mutable_captured_tensor() {
3487 ::tensorflow::CapturedTensor* _msg = _internal_mutable_captured_tensor();
3488 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.captured_tensor)
3489 return _msg;
3490 }
3491
3492 // map<string, .tensorflow.SaveableObject> saveable_objects = 11;
_internal_saveable_objects_size()3493 inline int SavedObject::_internal_saveable_objects_size() const {
3494 return _impl_.saveable_objects_.size();
3495 }
saveable_objects_size()3496 inline int SavedObject::saveable_objects_size() const {
3497 return _internal_saveable_objects_size();
3498 }
clear_saveable_objects()3499 inline void SavedObject::clear_saveable_objects() {
3500 _impl_.saveable_objects_.Clear();
3501 }
3502 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >&
_internal_saveable_objects()3503 SavedObject::_internal_saveable_objects() const {
3504 return _impl_.saveable_objects_.GetMap();
3505 }
3506 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >&
saveable_objects()3507 SavedObject::saveable_objects() const {
3508 // @@protoc_insertion_point(field_map:tensorflow.SavedObject.saveable_objects)
3509 return _internal_saveable_objects();
3510 }
3511 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >*
_internal_mutable_saveable_objects()3512 SavedObject::_internal_mutable_saveable_objects() {
3513 return _impl_.saveable_objects_.MutableMap();
3514 }
3515 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::SaveableObject >*
mutable_saveable_objects()3516 SavedObject::mutable_saveable_objects() {
3517 // @@protoc_insertion_point(field_mutable_map:tensorflow.SavedObject.saveable_objects)
3518 return _internal_mutable_saveable_objects();
3519 }
3520
3521 // string registered_name = 13;
clear_registered_name()3522 inline void SavedObject::clear_registered_name() {
3523 _impl_.registered_name_.ClearToEmpty();
3524 }
registered_name()3525 inline const std::string& SavedObject::registered_name() const {
3526 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.registered_name)
3527 return _internal_registered_name();
3528 }
3529 template <typename ArgT0, typename... ArgT>
3530 inline PROTOBUF_ALWAYS_INLINE
set_registered_name(ArgT0 && arg0,ArgT...args)3531 void SavedObject::set_registered_name(ArgT0&& arg0, ArgT... args) {
3532
3533 _impl_.registered_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3534 // @@protoc_insertion_point(field_set:tensorflow.SavedObject.registered_name)
3535 }
mutable_registered_name()3536 inline std::string* SavedObject::mutable_registered_name() {
3537 std::string* _s = _internal_mutable_registered_name();
3538 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.registered_name)
3539 return _s;
3540 }
_internal_registered_name()3541 inline const std::string& SavedObject::_internal_registered_name() const {
3542 return _impl_.registered_name_.Get();
3543 }
_internal_set_registered_name(const std::string & value)3544 inline void SavedObject::_internal_set_registered_name(const std::string& value) {
3545
3546 _impl_.registered_name_.Set(value, GetArenaForAllocation());
3547 }
_internal_mutable_registered_name()3548 inline std::string* SavedObject::_internal_mutable_registered_name() {
3549
3550 return _impl_.registered_name_.Mutable(GetArenaForAllocation());
3551 }
release_registered_name()3552 inline std::string* SavedObject::release_registered_name() {
3553 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.registered_name)
3554 return _impl_.registered_name_.Release();
3555 }
set_allocated_registered_name(std::string * registered_name)3556 inline void SavedObject::set_allocated_registered_name(std::string* registered_name) {
3557 _impl_.registered_name_.SetAllocated(registered_name, GetArenaForAllocation());
3558 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3559 if (_impl_.registered_name_.IsDefault()) {
3560 _impl_.registered_name_.Set("", GetArenaForAllocation());
3561 }
3562 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3563 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedObject.registered_name)
3564 }
3565
3566 // .google.protobuf.Any serialized_user_proto = 14;
_internal_has_serialized_user_proto()3567 inline bool SavedObject::_internal_has_serialized_user_proto() const {
3568 return this != internal_default_instance() && _impl_.serialized_user_proto_ != nullptr;
3569 }
has_serialized_user_proto()3570 inline bool SavedObject::has_serialized_user_proto() const {
3571 return _internal_has_serialized_user_proto();
3572 }
_internal_serialized_user_proto()3573 inline const ::PROTOBUF_NAMESPACE_ID::Any& SavedObject::_internal_serialized_user_proto() const {
3574 const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.serialized_user_proto_;
3575 return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
3576 ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
3577 }
serialized_user_proto()3578 inline const ::PROTOBUF_NAMESPACE_ID::Any& SavedObject::serialized_user_proto() const {
3579 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.serialized_user_proto)
3580 return _internal_serialized_user_proto();
3581 }
unsafe_arena_set_allocated_serialized_user_proto(::PROTOBUF_NAMESPACE_ID::Any * serialized_user_proto)3582 inline void SavedObject::unsafe_arena_set_allocated_serialized_user_proto(
3583 ::PROTOBUF_NAMESPACE_ID::Any* serialized_user_proto) {
3584 if (GetArenaForAllocation() == nullptr) {
3585 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serialized_user_proto_);
3586 }
3587 _impl_.serialized_user_proto_ = serialized_user_proto;
3588 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedObject.serialized_user_proto)
3589 }
release_serialized_user_proto()3590 inline ::PROTOBUF_NAMESPACE_ID::Any* SavedObject::release_serialized_user_proto() {
3591
3592 ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.serialized_user_proto_;
3593 _impl_.serialized_user_proto_ = nullptr;
3594 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3595 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3596 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3597 if (GetArenaForAllocation() == nullptr) { delete old; }
3598 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3599 if (GetArenaForAllocation() != nullptr) {
3600 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3601 }
3602 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3603 return temp;
3604 }
unsafe_arena_release_serialized_user_proto()3605 inline ::PROTOBUF_NAMESPACE_ID::Any* SavedObject::unsafe_arena_release_serialized_user_proto() {
3606 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.serialized_user_proto)
3607
3608 ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.serialized_user_proto_;
3609 _impl_.serialized_user_proto_ = nullptr;
3610 return temp;
3611 }
_internal_mutable_serialized_user_proto()3612 inline ::PROTOBUF_NAMESPACE_ID::Any* SavedObject::_internal_mutable_serialized_user_proto() {
3613
3614 if (_impl_.serialized_user_proto_ == nullptr) {
3615 auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
3616 _impl_.serialized_user_proto_ = p;
3617 }
3618 return _impl_.serialized_user_proto_;
3619 }
mutable_serialized_user_proto()3620 inline ::PROTOBUF_NAMESPACE_ID::Any* SavedObject::mutable_serialized_user_proto() {
3621 ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_serialized_user_proto();
3622 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.serialized_user_proto)
3623 return _msg;
3624 }
set_allocated_serialized_user_proto(::PROTOBUF_NAMESPACE_ID::Any * serialized_user_proto)3625 inline void SavedObject::set_allocated_serialized_user_proto(::PROTOBUF_NAMESPACE_ID::Any* serialized_user_proto) {
3626 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3627 if (message_arena == nullptr) {
3628 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.serialized_user_proto_);
3629 }
3630 if (serialized_user_proto) {
3631 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3632 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3633 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(serialized_user_proto));
3634 if (message_arena != submessage_arena) {
3635 serialized_user_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3636 message_arena, serialized_user_proto, submessage_arena);
3637 }
3638
3639 } else {
3640
3641 }
3642 _impl_.serialized_user_proto_ = serialized_user_proto;
3643 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedObject.serialized_user_proto)
3644 }
3645
3646 // string registered_saver = 16;
clear_registered_saver()3647 inline void SavedObject::clear_registered_saver() {
3648 _impl_.registered_saver_.ClearToEmpty();
3649 }
registered_saver()3650 inline const std::string& SavedObject::registered_saver() const {
3651 // @@protoc_insertion_point(field_get:tensorflow.SavedObject.registered_saver)
3652 return _internal_registered_saver();
3653 }
3654 template <typename ArgT0, typename... ArgT>
3655 inline PROTOBUF_ALWAYS_INLINE
set_registered_saver(ArgT0 && arg0,ArgT...args)3656 void SavedObject::set_registered_saver(ArgT0&& arg0, ArgT... args) {
3657
3658 _impl_.registered_saver_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3659 // @@protoc_insertion_point(field_set:tensorflow.SavedObject.registered_saver)
3660 }
mutable_registered_saver()3661 inline std::string* SavedObject::mutable_registered_saver() {
3662 std::string* _s = _internal_mutable_registered_saver();
3663 // @@protoc_insertion_point(field_mutable:tensorflow.SavedObject.registered_saver)
3664 return _s;
3665 }
_internal_registered_saver()3666 inline const std::string& SavedObject::_internal_registered_saver() const {
3667 return _impl_.registered_saver_.Get();
3668 }
_internal_set_registered_saver(const std::string & value)3669 inline void SavedObject::_internal_set_registered_saver(const std::string& value) {
3670
3671 _impl_.registered_saver_.Set(value, GetArenaForAllocation());
3672 }
_internal_mutable_registered_saver()3673 inline std::string* SavedObject::_internal_mutable_registered_saver() {
3674
3675 return _impl_.registered_saver_.Mutable(GetArenaForAllocation());
3676 }
release_registered_saver()3677 inline std::string* SavedObject::release_registered_saver() {
3678 // @@protoc_insertion_point(field_release:tensorflow.SavedObject.registered_saver)
3679 return _impl_.registered_saver_.Release();
3680 }
set_allocated_registered_saver(std::string * registered_saver)3681 inline void SavedObject::set_allocated_registered_saver(std::string* registered_saver) {
3682 _impl_.registered_saver_.SetAllocated(registered_saver, GetArenaForAllocation());
3683 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3684 if (_impl_.registered_saver_.IsDefault()) {
3685 _impl_.registered_saver_.Set("", GetArenaForAllocation());
3686 }
3687 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3688 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedObject.registered_saver)
3689 }
3690
has_kind()3691 inline bool SavedObject::has_kind() const {
3692 return kind_case() != KIND_NOT_SET;
3693 }
clear_has_kind()3694 inline void SavedObject::clear_has_kind() {
3695 _impl_._oneof_case_[0] = KIND_NOT_SET;
3696 }
kind_case()3697 inline SavedObject::KindCase SavedObject::kind_case() const {
3698 return SavedObject::KindCase(_impl_._oneof_case_[0]);
3699 }
3700 // -------------------------------------------------------------------
3701
3702 // SavedUserObject
3703
3704 // string identifier = 1;
clear_identifier()3705 inline void SavedUserObject::clear_identifier() {
3706 _impl_.identifier_.ClearToEmpty();
3707 }
identifier()3708 inline const std::string& SavedUserObject::identifier() const {
3709 // @@protoc_insertion_point(field_get:tensorflow.SavedUserObject.identifier)
3710 return _internal_identifier();
3711 }
3712 template <typename ArgT0, typename... ArgT>
3713 inline PROTOBUF_ALWAYS_INLINE
set_identifier(ArgT0 && arg0,ArgT...args)3714 void SavedUserObject::set_identifier(ArgT0&& arg0, ArgT... args) {
3715
3716 _impl_.identifier_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3717 // @@protoc_insertion_point(field_set:tensorflow.SavedUserObject.identifier)
3718 }
mutable_identifier()3719 inline std::string* SavedUserObject::mutable_identifier() {
3720 std::string* _s = _internal_mutable_identifier();
3721 // @@protoc_insertion_point(field_mutable:tensorflow.SavedUserObject.identifier)
3722 return _s;
3723 }
_internal_identifier()3724 inline const std::string& SavedUserObject::_internal_identifier() const {
3725 return _impl_.identifier_.Get();
3726 }
_internal_set_identifier(const std::string & value)3727 inline void SavedUserObject::_internal_set_identifier(const std::string& value) {
3728
3729 _impl_.identifier_.Set(value, GetArenaForAllocation());
3730 }
_internal_mutable_identifier()3731 inline std::string* SavedUserObject::_internal_mutable_identifier() {
3732
3733 return _impl_.identifier_.Mutable(GetArenaForAllocation());
3734 }
release_identifier()3735 inline std::string* SavedUserObject::release_identifier() {
3736 // @@protoc_insertion_point(field_release:tensorflow.SavedUserObject.identifier)
3737 return _impl_.identifier_.Release();
3738 }
set_allocated_identifier(std::string * identifier)3739 inline void SavedUserObject::set_allocated_identifier(std::string* identifier) {
3740 _impl_.identifier_.SetAllocated(identifier, GetArenaForAllocation());
3741 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3742 if (_impl_.identifier_.IsDefault()) {
3743 _impl_.identifier_.Set("", GetArenaForAllocation());
3744 }
3745 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3746 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedUserObject.identifier)
3747 }
3748
3749 // .tensorflow.VersionDef version = 2;
_internal_has_version()3750 inline bool SavedUserObject::_internal_has_version() const {
3751 return this != internal_default_instance() && _impl_.version_ != nullptr;
3752 }
has_version()3753 inline bool SavedUserObject::has_version() const {
3754 return _internal_has_version();
3755 }
_internal_version()3756 inline const ::tensorflow::VersionDef& SavedUserObject::_internal_version() const {
3757 const ::tensorflow::VersionDef* p = _impl_.version_;
3758 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::VersionDef&>(
3759 ::tensorflow::_VersionDef_default_instance_);
3760 }
version()3761 inline const ::tensorflow::VersionDef& SavedUserObject::version() const {
3762 // @@protoc_insertion_point(field_get:tensorflow.SavedUserObject.version)
3763 return _internal_version();
3764 }
unsafe_arena_set_allocated_version(::tensorflow::VersionDef * version)3765 inline void SavedUserObject::unsafe_arena_set_allocated_version(
3766 ::tensorflow::VersionDef* version) {
3767 if (GetArenaForAllocation() == nullptr) {
3768 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
3769 }
3770 _impl_.version_ = version;
3771 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedUserObject.version)
3772 }
release_version()3773 inline ::tensorflow::VersionDef* SavedUserObject::release_version() {
3774
3775 ::tensorflow::VersionDef* temp = _impl_.version_;
3776 _impl_.version_ = nullptr;
3777 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3778 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3779 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3780 if (GetArenaForAllocation() == nullptr) { delete old; }
3781 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3782 if (GetArenaForAllocation() != nullptr) {
3783 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3784 }
3785 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3786 return temp;
3787 }
unsafe_arena_release_version()3788 inline ::tensorflow::VersionDef* SavedUserObject::unsafe_arena_release_version() {
3789 // @@protoc_insertion_point(field_release:tensorflow.SavedUserObject.version)
3790
3791 ::tensorflow::VersionDef* temp = _impl_.version_;
3792 _impl_.version_ = nullptr;
3793 return temp;
3794 }
_internal_mutable_version()3795 inline ::tensorflow::VersionDef* SavedUserObject::_internal_mutable_version() {
3796
3797 if (_impl_.version_ == nullptr) {
3798 auto* p = CreateMaybeMessage<::tensorflow::VersionDef>(GetArenaForAllocation());
3799 _impl_.version_ = p;
3800 }
3801 return _impl_.version_;
3802 }
mutable_version()3803 inline ::tensorflow::VersionDef* SavedUserObject::mutable_version() {
3804 ::tensorflow::VersionDef* _msg = _internal_mutable_version();
3805 // @@protoc_insertion_point(field_mutable:tensorflow.SavedUserObject.version)
3806 return _msg;
3807 }
set_allocated_version(::tensorflow::VersionDef * version)3808 inline void SavedUserObject::set_allocated_version(::tensorflow::VersionDef* version) {
3809 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3810 if (message_arena == nullptr) {
3811 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.version_);
3812 }
3813 if (version) {
3814 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3815 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3816 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(version));
3817 if (message_arena != submessage_arena) {
3818 version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3819 message_arena, version, submessage_arena);
3820 }
3821
3822 } else {
3823
3824 }
3825 _impl_.version_ = version;
3826 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedUserObject.version)
3827 }
3828
3829 // string metadata = 3 [deprecated = true];
clear_metadata()3830 inline void SavedUserObject::clear_metadata() {
3831 _impl_.metadata_.ClearToEmpty();
3832 }
metadata()3833 inline const std::string& SavedUserObject::metadata() const {
3834 // @@protoc_insertion_point(field_get:tensorflow.SavedUserObject.metadata)
3835 return _internal_metadata();
3836 }
3837 template <typename ArgT0, typename... ArgT>
3838 inline PROTOBUF_ALWAYS_INLINE
set_metadata(ArgT0 && arg0,ArgT...args)3839 void SavedUserObject::set_metadata(ArgT0&& arg0, ArgT... args) {
3840
3841 _impl_.metadata_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3842 // @@protoc_insertion_point(field_set:tensorflow.SavedUserObject.metadata)
3843 }
mutable_metadata()3844 inline std::string* SavedUserObject::mutable_metadata() {
3845 std::string* _s = _internal_mutable_metadata();
3846 // @@protoc_insertion_point(field_mutable:tensorflow.SavedUserObject.metadata)
3847 return _s;
3848 }
_internal_metadata()3849 inline const std::string& SavedUserObject::_internal_metadata() const {
3850 return _impl_.metadata_.Get();
3851 }
_internal_set_metadata(const std::string & value)3852 inline void SavedUserObject::_internal_set_metadata(const std::string& value) {
3853
3854 _impl_.metadata_.Set(value, GetArenaForAllocation());
3855 }
_internal_mutable_metadata()3856 inline std::string* SavedUserObject::_internal_mutable_metadata() {
3857
3858 return _impl_.metadata_.Mutable(GetArenaForAllocation());
3859 }
release_metadata()3860 inline std::string* SavedUserObject::release_metadata() {
3861 // @@protoc_insertion_point(field_release:tensorflow.SavedUserObject.metadata)
3862 return _impl_.metadata_.Release();
3863 }
set_allocated_metadata(std::string * metadata)3864 inline void SavedUserObject::set_allocated_metadata(std::string* metadata) {
3865 _impl_.metadata_.SetAllocated(metadata, GetArenaForAllocation());
3866 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3867 if (_impl_.metadata_.IsDefault()) {
3868 _impl_.metadata_.Set("", GetArenaForAllocation());
3869 }
3870 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3871 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedUserObject.metadata)
3872 }
3873
3874 // -------------------------------------------------------------------
3875
3876 // SavedAsset
3877
3878 // int32 asset_file_def_index = 1;
clear_asset_file_def_index()3879 inline void SavedAsset::clear_asset_file_def_index() {
3880 _impl_.asset_file_def_index_ = 0;
3881 }
_internal_asset_file_def_index()3882 inline ::int32_t SavedAsset::_internal_asset_file_def_index() const {
3883 return _impl_.asset_file_def_index_;
3884 }
asset_file_def_index()3885 inline ::int32_t SavedAsset::asset_file_def_index() const {
3886 // @@protoc_insertion_point(field_get:tensorflow.SavedAsset.asset_file_def_index)
3887 return _internal_asset_file_def_index();
3888 }
_internal_set_asset_file_def_index(::int32_t value)3889 inline void SavedAsset::_internal_set_asset_file_def_index(::int32_t value) {
3890
3891 _impl_.asset_file_def_index_ = value;
3892 }
set_asset_file_def_index(::int32_t value)3893 inline void SavedAsset::set_asset_file_def_index(::int32_t value) {
3894 _internal_set_asset_file_def_index(value);
3895 // @@protoc_insertion_point(field_set:tensorflow.SavedAsset.asset_file_def_index)
3896 }
3897
3898 // -------------------------------------------------------------------
3899
3900 // SavedFunction
3901
3902 // repeated string concrete_functions = 1;
_internal_concrete_functions_size()3903 inline int SavedFunction::_internal_concrete_functions_size() const {
3904 return _impl_.concrete_functions_.size();
3905 }
concrete_functions_size()3906 inline int SavedFunction::concrete_functions_size() const {
3907 return _internal_concrete_functions_size();
3908 }
clear_concrete_functions()3909 inline void SavedFunction::clear_concrete_functions() {
3910 _impl_.concrete_functions_.Clear();
3911 }
add_concrete_functions()3912 inline std::string* SavedFunction::add_concrete_functions() {
3913 std::string* _s = _internal_add_concrete_functions();
3914 // @@protoc_insertion_point(field_add_mutable:tensorflow.SavedFunction.concrete_functions)
3915 return _s;
3916 }
_internal_concrete_functions(int index)3917 inline const std::string& SavedFunction::_internal_concrete_functions(int index) const {
3918 return _impl_.concrete_functions_.Get(index);
3919 }
concrete_functions(int index)3920 inline const std::string& SavedFunction::concrete_functions(int index) const {
3921 // @@protoc_insertion_point(field_get:tensorflow.SavedFunction.concrete_functions)
3922 return _internal_concrete_functions(index);
3923 }
mutable_concrete_functions(int index)3924 inline std::string* SavedFunction::mutable_concrete_functions(int index) {
3925 // @@protoc_insertion_point(field_mutable:tensorflow.SavedFunction.concrete_functions)
3926 return _impl_.concrete_functions_.Mutable(index);
3927 }
set_concrete_functions(int index,const std::string & value)3928 inline void SavedFunction::set_concrete_functions(int index, const std::string& value) {
3929 _impl_.concrete_functions_.Mutable(index)->assign(value);
3930 // @@protoc_insertion_point(field_set:tensorflow.SavedFunction.concrete_functions)
3931 }
set_concrete_functions(int index,std::string && value)3932 inline void SavedFunction::set_concrete_functions(int index, std::string&& value) {
3933 _impl_.concrete_functions_.Mutable(index)->assign(std::move(value));
3934 // @@protoc_insertion_point(field_set:tensorflow.SavedFunction.concrete_functions)
3935 }
set_concrete_functions(int index,const char * value)3936 inline void SavedFunction::set_concrete_functions(int index, const char* value) {
3937 GOOGLE_DCHECK(value != nullptr);
3938 _impl_.concrete_functions_.Mutable(index)->assign(value);
3939 // @@protoc_insertion_point(field_set_char:tensorflow.SavedFunction.concrete_functions)
3940 }
set_concrete_functions(int index,const char * value,size_t size)3941 inline void SavedFunction::set_concrete_functions(int index, const char* value, size_t size) {
3942 _impl_.concrete_functions_.Mutable(index)->assign(
3943 reinterpret_cast<const char*>(value), size);
3944 // @@protoc_insertion_point(field_set_pointer:tensorflow.SavedFunction.concrete_functions)
3945 }
_internal_add_concrete_functions()3946 inline std::string* SavedFunction::_internal_add_concrete_functions() {
3947 return _impl_.concrete_functions_.Add();
3948 }
add_concrete_functions(const std::string & value)3949 inline void SavedFunction::add_concrete_functions(const std::string& value) {
3950 _impl_.concrete_functions_.Add()->assign(value);
3951 // @@protoc_insertion_point(field_add:tensorflow.SavedFunction.concrete_functions)
3952 }
add_concrete_functions(std::string && value)3953 inline void SavedFunction::add_concrete_functions(std::string&& value) {
3954 _impl_.concrete_functions_.Add(std::move(value));
3955 // @@protoc_insertion_point(field_add:tensorflow.SavedFunction.concrete_functions)
3956 }
add_concrete_functions(const char * value)3957 inline void SavedFunction::add_concrete_functions(const char* value) {
3958 GOOGLE_DCHECK(value != nullptr);
3959 _impl_.concrete_functions_.Add()->assign(value);
3960 // @@protoc_insertion_point(field_add_char:tensorflow.SavedFunction.concrete_functions)
3961 }
add_concrete_functions(const char * value,size_t size)3962 inline void SavedFunction::add_concrete_functions(const char* value, size_t size) {
3963 _impl_.concrete_functions_.Add()->assign(reinterpret_cast<const char*>(value), size);
3964 // @@protoc_insertion_point(field_add_pointer:tensorflow.SavedFunction.concrete_functions)
3965 }
3966 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
concrete_functions()3967 SavedFunction::concrete_functions() const {
3968 // @@protoc_insertion_point(field_list:tensorflow.SavedFunction.concrete_functions)
3969 return _impl_.concrete_functions_;
3970 }
3971 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_concrete_functions()3972 SavedFunction::mutable_concrete_functions() {
3973 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedFunction.concrete_functions)
3974 return &_impl_.concrete_functions_;
3975 }
3976
3977 // .tensorflow.FunctionSpec function_spec = 2;
_internal_has_function_spec()3978 inline bool SavedFunction::_internal_has_function_spec() const {
3979 return this != internal_default_instance() && _impl_.function_spec_ != nullptr;
3980 }
has_function_spec()3981 inline bool SavedFunction::has_function_spec() const {
3982 return _internal_has_function_spec();
3983 }
clear_function_spec()3984 inline void SavedFunction::clear_function_spec() {
3985 if (GetArenaForAllocation() == nullptr && _impl_.function_spec_ != nullptr) {
3986 delete _impl_.function_spec_;
3987 }
3988 _impl_.function_spec_ = nullptr;
3989 }
_internal_function_spec()3990 inline const ::tensorflow::FunctionSpec& SavedFunction::_internal_function_spec() const {
3991 const ::tensorflow::FunctionSpec* p = _impl_.function_spec_;
3992 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::FunctionSpec&>(
3993 ::tensorflow::_FunctionSpec_default_instance_);
3994 }
function_spec()3995 inline const ::tensorflow::FunctionSpec& SavedFunction::function_spec() const {
3996 // @@protoc_insertion_point(field_get:tensorflow.SavedFunction.function_spec)
3997 return _internal_function_spec();
3998 }
unsafe_arena_set_allocated_function_spec(::tensorflow::FunctionSpec * function_spec)3999 inline void SavedFunction::unsafe_arena_set_allocated_function_spec(
4000 ::tensorflow::FunctionSpec* function_spec) {
4001 if (GetArenaForAllocation() == nullptr) {
4002 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.function_spec_);
4003 }
4004 _impl_.function_spec_ = function_spec;
4005 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedFunction.function_spec)
4006 }
release_function_spec()4007 inline ::tensorflow::FunctionSpec* SavedFunction::release_function_spec() {
4008
4009 ::tensorflow::FunctionSpec* temp = _impl_.function_spec_;
4010 _impl_.function_spec_ = nullptr;
4011 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4012 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4013 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4014 if (GetArenaForAllocation() == nullptr) { delete old; }
4015 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4016 if (GetArenaForAllocation() != nullptr) {
4017 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4018 }
4019 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4020 return temp;
4021 }
unsafe_arena_release_function_spec()4022 inline ::tensorflow::FunctionSpec* SavedFunction::unsafe_arena_release_function_spec() {
4023 // @@protoc_insertion_point(field_release:tensorflow.SavedFunction.function_spec)
4024
4025 ::tensorflow::FunctionSpec* temp = _impl_.function_spec_;
4026 _impl_.function_spec_ = nullptr;
4027 return temp;
4028 }
_internal_mutable_function_spec()4029 inline ::tensorflow::FunctionSpec* SavedFunction::_internal_mutable_function_spec() {
4030
4031 if (_impl_.function_spec_ == nullptr) {
4032 auto* p = CreateMaybeMessage<::tensorflow::FunctionSpec>(GetArenaForAllocation());
4033 _impl_.function_spec_ = p;
4034 }
4035 return _impl_.function_spec_;
4036 }
mutable_function_spec()4037 inline ::tensorflow::FunctionSpec* SavedFunction::mutable_function_spec() {
4038 ::tensorflow::FunctionSpec* _msg = _internal_mutable_function_spec();
4039 // @@protoc_insertion_point(field_mutable:tensorflow.SavedFunction.function_spec)
4040 return _msg;
4041 }
set_allocated_function_spec(::tensorflow::FunctionSpec * function_spec)4042 inline void SavedFunction::set_allocated_function_spec(::tensorflow::FunctionSpec* function_spec) {
4043 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4044 if (message_arena == nullptr) {
4045 delete _impl_.function_spec_;
4046 }
4047 if (function_spec) {
4048 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4049 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(function_spec);
4050 if (message_arena != submessage_arena) {
4051 function_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4052 message_arena, function_spec, submessage_arena);
4053 }
4054
4055 } else {
4056
4057 }
4058 _impl_.function_spec_ = function_spec;
4059 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedFunction.function_spec)
4060 }
4061
4062 // -------------------------------------------------------------------
4063
4064 // CapturedTensor
4065
4066 // string name = 1;
clear_name()4067 inline void CapturedTensor::clear_name() {
4068 _impl_.name_.ClearToEmpty();
4069 }
name()4070 inline const std::string& CapturedTensor::name() const {
4071 // @@protoc_insertion_point(field_get:tensorflow.CapturedTensor.name)
4072 return _internal_name();
4073 }
4074 template <typename ArgT0, typename... ArgT>
4075 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)4076 void CapturedTensor::set_name(ArgT0&& arg0, ArgT... args) {
4077
4078 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4079 // @@protoc_insertion_point(field_set:tensorflow.CapturedTensor.name)
4080 }
mutable_name()4081 inline std::string* CapturedTensor::mutable_name() {
4082 std::string* _s = _internal_mutable_name();
4083 // @@protoc_insertion_point(field_mutable:tensorflow.CapturedTensor.name)
4084 return _s;
4085 }
_internal_name()4086 inline const std::string& CapturedTensor::_internal_name() const {
4087 return _impl_.name_.Get();
4088 }
_internal_set_name(const std::string & value)4089 inline void CapturedTensor::_internal_set_name(const std::string& value) {
4090
4091 _impl_.name_.Set(value, GetArenaForAllocation());
4092 }
_internal_mutable_name()4093 inline std::string* CapturedTensor::_internal_mutable_name() {
4094
4095 return _impl_.name_.Mutable(GetArenaForAllocation());
4096 }
release_name()4097 inline std::string* CapturedTensor::release_name() {
4098 // @@protoc_insertion_point(field_release:tensorflow.CapturedTensor.name)
4099 return _impl_.name_.Release();
4100 }
set_allocated_name(std::string * name)4101 inline void CapturedTensor::set_allocated_name(std::string* name) {
4102 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
4103 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4104 if (_impl_.name_.IsDefault()) {
4105 _impl_.name_.Set("", GetArenaForAllocation());
4106 }
4107 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4108 // @@protoc_insertion_point(field_set_allocated:tensorflow.CapturedTensor.name)
4109 }
4110
4111 // string concrete_function = 2;
clear_concrete_function()4112 inline void CapturedTensor::clear_concrete_function() {
4113 _impl_.concrete_function_.ClearToEmpty();
4114 }
concrete_function()4115 inline const std::string& CapturedTensor::concrete_function() const {
4116 // @@protoc_insertion_point(field_get:tensorflow.CapturedTensor.concrete_function)
4117 return _internal_concrete_function();
4118 }
4119 template <typename ArgT0, typename... ArgT>
4120 inline PROTOBUF_ALWAYS_INLINE
set_concrete_function(ArgT0 && arg0,ArgT...args)4121 void CapturedTensor::set_concrete_function(ArgT0&& arg0, ArgT... args) {
4122
4123 _impl_.concrete_function_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4124 // @@protoc_insertion_point(field_set:tensorflow.CapturedTensor.concrete_function)
4125 }
mutable_concrete_function()4126 inline std::string* CapturedTensor::mutable_concrete_function() {
4127 std::string* _s = _internal_mutable_concrete_function();
4128 // @@protoc_insertion_point(field_mutable:tensorflow.CapturedTensor.concrete_function)
4129 return _s;
4130 }
_internal_concrete_function()4131 inline const std::string& CapturedTensor::_internal_concrete_function() const {
4132 return _impl_.concrete_function_.Get();
4133 }
_internal_set_concrete_function(const std::string & value)4134 inline void CapturedTensor::_internal_set_concrete_function(const std::string& value) {
4135
4136 _impl_.concrete_function_.Set(value, GetArenaForAllocation());
4137 }
_internal_mutable_concrete_function()4138 inline std::string* CapturedTensor::_internal_mutable_concrete_function() {
4139
4140 return _impl_.concrete_function_.Mutable(GetArenaForAllocation());
4141 }
release_concrete_function()4142 inline std::string* CapturedTensor::release_concrete_function() {
4143 // @@protoc_insertion_point(field_release:tensorflow.CapturedTensor.concrete_function)
4144 return _impl_.concrete_function_.Release();
4145 }
set_allocated_concrete_function(std::string * concrete_function)4146 inline void CapturedTensor::set_allocated_concrete_function(std::string* concrete_function) {
4147 _impl_.concrete_function_.SetAllocated(concrete_function, GetArenaForAllocation());
4148 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4149 if (_impl_.concrete_function_.IsDefault()) {
4150 _impl_.concrete_function_.Set("", GetArenaForAllocation());
4151 }
4152 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4153 // @@protoc_insertion_point(field_set_allocated:tensorflow.CapturedTensor.concrete_function)
4154 }
4155
4156 // -------------------------------------------------------------------
4157
4158 // SavedConcreteFunction
4159
4160 // repeated int32 bound_inputs = 2;
_internal_bound_inputs_size()4161 inline int SavedConcreteFunction::_internal_bound_inputs_size() const {
4162 return _impl_.bound_inputs_.size();
4163 }
bound_inputs_size()4164 inline int SavedConcreteFunction::bound_inputs_size() const {
4165 return _internal_bound_inputs_size();
4166 }
clear_bound_inputs()4167 inline void SavedConcreteFunction::clear_bound_inputs() {
4168 _impl_.bound_inputs_.Clear();
4169 }
_internal_bound_inputs(int index)4170 inline ::int32_t SavedConcreteFunction::_internal_bound_inputs(int index) const {
4171 return _impl_.bound_inputs_.Get(index);
4172 }
bound_inputs(int index)4173 inline ::int32_t SavedConcreteFunction::bound_inputs(int index) const {
4174 // @@protoc_insertion_point(field_get:tensorflow.SavedConcreteFunction.bound_inputs)
4175 return _internal_bound_inputs(index);
4176 }
set_bound_inputs(int index,::int32_t value)4177 inline void SavedConcreteFunction::set_bound_inputs(int index, ::int32_t value) {
4178 _impl_.bound_inputs_.Set(index, value);
4179 // @@protoc_insertion_point(field_set:tensorflow.SavedConcreteFunction.bound_inputs)
4180 }
_internal_add_bound_inputs(::int32_t value)4181 inline void SavedConcreteFunction::_internal_add_bound_inputs(::int32_t value) {
4182 _impl_.bound_inputs_.Add(value);
4183 }
add_bound_inputs(::int32_t value)4184 inline void SavedConcreteFunction::add_bound_inputs(::int32_t value) {
4185 _internal_add_bound_inputs(value);
4186 // @@protoc_insertion_point(field_add:tensorflow.SavedConcreteFunction.bound_inputs)
4187 }
4188 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
_internal_bound_inputs()4189 SavedConcreteFunction::_internal_bound_inputs() const {
4190 return _impl_.bound_inputs_;
4191 }
4192 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
bound_inputs()4193 SavedConcreteFunction::bound_inputs() const {
4194 // @@protoc_insertion_point(field_list:tensorflow.SavedConcreteFunction.bound_inputs)
4195 return _internal_bound_inputs();
4196 }
4197 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
_internal_mutable_bound_inputs()4198 SavedConcreteFunction::_internal_mutable_bound_inputs() {
4199 return &_impl_.bound_inputs_;
4200 }
4201 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
mutable_bound_inputs()4202 SavedConcreteFunction::mutable_bound_inputs() {
4203 // @@protoc_insertion_point(field_mutable_list:tensorflow.SavedConcreteFunction.bound_inputs)
4204 return _internal_mutable_bound_inputs();
4205 }
4206
4207 // .tensorflow.StructuredValue canonicalized_input_signature = 3;
_internal_has_canonicalized_input_signature()4208 inline bool SavedConcreteFunction::_internal_has_canonicalized_input_signature() const {
4209 return this != internal_default_instance() && _impl_.canonicalized_input_signature_ != nullptr;
4210 }
has_canonicalized_input_signature()4211 inline bool SavedConcreteFunction::has_canonicalized_input_signature() const {
4212 return _internal_has_canonicalized_input_signature();
4213 }
_internal_canonicalized_input_signature()4214 inline const ::tensorflow::StructuredValue& SavedConcreteFunction::_internal_canonicalized_input_signature() const {
4215 const ::tensorflow::StructuredValue* p = _impl_.canonicalized_input_signature_;
4216 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::StructuredValue&>(
4217 ::tensorflow::_StructuredValue_default_instance_);
4218 }
canonicalized_input_signature()4219 inline const ::tensorflow::StructuredValue& SavedConcreteFunction::canonicalized_input_signature() const {
4220 // @@protoc_insertion_point(field_get:tensorflow.SavedConcreteFunction.canonicalized_input_signature)
4221 return _internal_canonicalized_input_signature();
4222 }
unsafe_arena_set_allocated_canonicalized_input_signature(::tensorflow::StructuredValue * canonicalized_input_signature)4223 inline void SavedConcreteFunction::unsafe_arena_set_allocated_canonicalized_input_signature(
4224 ::tensorflow::StructuredValue* canonicalized_input_signature) {
4225 if (GetArenaForAllocation() == nullptr) {
4226 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.canonicalized_input_signature_);
4227 }
4228 _impl_.canonicalized_input_signature_ = canonicalized_input_signature;
4229 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SavedConcreteFunction.canonicalized_input_signature)
4230 }
release_canonicalized_input_signature()4231 inline ::tensorflow::StructuredValue* SavedConcreteFunction::release_canonicalized_input_signature() {
4232
4233 ::tensorflow::StructuredValue* temp = _impl_.canonicalized_input_signature_;
4234 _impl_.canonicalized_input_signature_ = nullptr;
4235 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4236 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4237 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4238 if (GetArenaForAllocation() == nullptr) { delete old; }
4239 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4240 if (GetArenaForAllocation() != nullptr) {
4241 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4242 }
4243 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4244 return temp;
4245 }
unsafe_arena_release_canonicalized_input_signature()4246 inline ::tensorflow::StructuredValue* SavedConcreteFunction::unsafe_arena_release_canonicalized_input_signature() {
4247 // @@protoc_insertion_point(field_release:tensorflow.SavedConcreteFunction.canonicalized_input_signature)
4248
4249 ::tensorflow::StructuredValue* temp = _impl_.canonicalized_input_signature_;
4250 _impl_.canonicalized_input_signature_ = nullptr;
4251 return temp;
4252 }
_internal_mutable_canonicalized_input_signature()4253 inline ::tensorflow::StructuredValue* SavedConcreteFunction::_internal_mutable_canonicalized_input_signature() {
4254
4255 if (_impl_.canonicalized_input_signature_ == nullptr) {
4256 auto* p = CreateMaybeMessage<::tensorflow::StructuredValue>(GetArenaForAllocation());
4257 _impl_.canonicalized_input_signature_ = p;
4258 }
4259 return _impl_.canonicalized_input_signature_;
4260 }
mutable_canonicalized_input_signature()4261 inline ::tensorflow::StructuredValue* SavedConcreteFunction::mutable_canonicalized_input_signature() {
4262 ::tensorflow::StructuredValue* _msg = _internal_mutable_canonicalized_input_signature();
4263 // @@protoc_insertion_point(field_mutable:tensorflow.SavedConcreteFunction.canonicalized_input_signature)
4264 return _msg;
4265 }
set_allocated_canonicalized_input_signature(::tensorflow::StructuredValue * canonicalized_input_signature)4266 inline void SavedConcreteFunction::set_allocated_canonicalized_input_signature(::tensorflow::StructuredValue* canonicalized_input_signature) {
4267 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4268 if (message_arena == nullptr) {
4269 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.canonicalized_input_signature_);
4270 }
4271 if (canonicalized_input_signature) {
4272 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4273 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4274 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(canonicalized_input_signature));
4275 if (message_arena != submessage_arena) {
4276 canonicalized_input_signature = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4277 message_arena, canonicalized_input_signature, submessage_arena);
4278 }
4279
4280 } else {
4281
4282 }
4283 _impl_.canonicalized_input_signature_ = canonicalized_input_signature;
4284 // @@protoc_insertion_point(field_set_allocated:tensorflow.SavedConcreteFunction.canonicalized_input_signature)
4285 }
4286
4287 // .tensorflow.StructuredValue output_signature = 4;
_internal_has_output_signature()4288 inline bool SavedConcreteFunction::_internal_has_output_signature() const {
4289 return this != internal_default_instance() && _impl_.output_signature_ != nullptr;
4290 }
has_output_signature()4291 inline bool SavedConcreteFunction::has_output_signature() const {
4292 return _internal_has_output_signature();
4293 }
_internal_output_signature()4294 inline const ::tensorflow::StructuredValue& SavedConcreteFunction::_internal_output_signature() const {
4295 const ::tensorflow::StructuredValue* p = _impl_.output_signature_;
4296 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::StructuredValue&>(
4297 ::tensorflow::_StructuredValue_default_instance_);
4298 }
output_signature()4299