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