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