1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/util/test_log.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2futil_2ftest_5flog_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2futil_2ftest_5flog_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/map.h> // IWYU pragma: export
35#include <google/protobuf/map_entry.h>
36#include <google/protobuf/map_field_inl.h>
37#include <google/protobuf/generated_enum_reflection.h>
38#include <google/protobuf/unknown_field_set.h>
39#include <google/protobuf/any.pb.h>
40#include <google/protobuf/wrappers.pb.h>
41// @@protoc_insertion_point(includes)
42#include <google/protobuf/port_def.inc>
43#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2futil_2ftest_5flog_2eproto
44PROTOBUF_NAMESPACE_OPEN
45namespace internal {
46class AnyMetadata;
47} // namespace internal
48PROTOBUF_NAMESPACE_CLOSE
49
50// Internal implementation detail -- do not use these members.
51struct TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto {
52 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
53 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
54 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
55 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
56 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[17]
57 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
58 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
59 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
60 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
61};
62extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
63namespace tensorflow {
64class AvailableDeviceInfo;
65class AvailableDeviceInfoDefaultTypeInternal;
66extern AvailableDeviceInfoDefaultTypeInternal _AvailableDeviceInfo_default_instance_;
67class BenchmarkEntries;
68class BenchmarkEntriesDefaultTypeInternal;
69extern BenchmarkEntriesDefaultTypeInternal _BenchmarkEntries_default_instance_;
70class BenchmarkEntry;
71class BenchmarkEntryDefaultTypeInternal;
72extern BenchmarkEntryDefaultTypeInternal _BenchmarkEntry_default_instance_;
73class BenchmarkEntry_ExtrasEntry_DoNotUse;
74class BenchmarkEntry_ExtrasEntry_DoNotUseDefaultTypeInternal;
75extern BenchmarkEntry_ExtrasEntry_DoNotUseDefaultTypeInternal _BenchmarkEntry_ExtrasEntry_DoNotUse_default_instance_;
76class BuildConfiguration;
77class BuildConfigurationDefaultTypeInternal;
78extern BuildConfigurationDefaultTypeInternal _BuildConfiguration_default_instance_;
79class CPUInfo;
80class CPUInfoDefaultTypeInternal;
81extern CPUInfoDefaultTypeInternal _CPUInfo_default_instance_;
82class CPUInfo_CacheSizeEntry_DoNotUse;
83class CPUInfo_CacheSizeEntry_DoNotUseDefaultTypeInternal;
84extern CPUInfo_CacheSizeEntry_DoNotUseDefaultTypeInternal _CPUInfo_CacheSizeEntry_DoNotUse_default_instance_;
85class CommitId;
86class CommitIdDefaultTypeInternal;
87extern CommitIdDefaultTypeInternal _CommitId_default_instance_;
88class EntryValue;
89class EntryValueDefaultTypeInternal;
90extern EntryValueDefaultTypeInternal _EntryValue_default_instance_;
91class GPUInfo;
92class GPUInfoDefaultTypeInternal;
93extern GPUInfoDefaultTypeInternal _GPUInfo_default_instance_;
94class MachineConfiguration;
95class MachineConfigurationDefaultTypeInternal;
96extern MachineConfigurationDefaultTypeInternal _MachineConfiguration_default_instance_;
97class MemoryInfo;
98class MemoryInfoDefaultTypeInternal;
99extern MemoryInfoDefaultTypeInternal _MemoryInfo_default_instance_;
100class MetricEntry;
101class MetricEntryDefaultTypeInternal;
102extern MetricEntryDefaultTypeInternal _MetricEntry_default_instance_;
103class PlatformInfo;
104class PlatformInfoDefaultTypeInternal;
105extern PlatformInfoDefaultTypeInternal _PlatformInfo_default_instance_;
106class RunConfiguration;
107class RunConfigurationDefaultTypeInternal;
108extern RunConfigurationDefaultTypeInternal _RunConfiguration_default_instance_;
109class RunConfiguration_EnvVarsEntry_DoNotUse;
110class RunConfiguration_EnvVarsEntry_DoNotUseDefaultTypeInternal;
111extern RunConfiguration_EnvVarsEntry_DoNotUseDefaultTypeInternal _RunConfiguration_EnvVarsEntry_DoNotUse_default_instance_;
112class TestResults;
113class TestResultsDefaultTypeInternal;
114extern TestResultsDefaultTypeInternal _TestResults_default_instance_;
115} // namespace tensorflow
116PROTOBUF_NAMESPACE_OPEN
117template<> ::tensorflow::AvailableDeviceInfo* Arena::CreateMaybeMessage<::tensorflow::AvailableDeviceInfo>(Arena*);
118template<> ::tensorflow::BenchmarkEntries* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntries>(Arena*);
119template<> ::tensorflow::BenchmarkEntry* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntry>(Arena*);
120template<> ::tensorflow::BenchmarkEntry_ExtrasEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::BenchmarkEntry_ExtrasEntry_DoNotUse>(Arena*);
121template<> ::tensorflow::BuildConfiguration* Arena::CreateMaybeMessage<::tensorflow::BuildConfiguration>(Arena*);
122template<> ::tensorflow::CPUInfo* Arena::CreateMaybeMessage<::tensorflow::CPUInfo>(Arena*);
123template<> ::tensorflow::CPUInfo_CacheSizeEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::CPUInfo_CacheSizeEntry_DoNotUse>(Arena*);
124template<> ::tensorflow::CommitId* Arena::CreateMaybeMessage<::tensorflow::CommitId>(Arena*);
125template<> ::tensorflow::EntryValue* Arena::CreateMaybeMessage<::tensorflow::EntryValue>(Arena*);
126template<> ::tensorflow::GPUInfo* Arena::CreateMaybeMessage<::tensorflow::GPUInfo>(Arena*);
127template<> ::tensorflow::MachineConfiguration* Arena::CreateMaybeMessage<::tensorflow::MachineConfiguration>(Arena*);
128template<> ::tensorflow::MemoryInfo* Arena::CreateMaybeMessage<::tensorflow::MemoryInfo>(Arena*);
129template<> ::tensorflow::MetricEntry* Arena::CreateMaybeMessage<::tensorflow::MetricEntry>(Arena*);
130template<> ::tensorflow::PlatformInfo* Arena::CreateMaybeMessage<::tensorflow::PlatformInfo>(Arena*);
131template<> ::tensorflow::RunConfiguration* Arena::CreateMaybeMessage<::tensorflow::RunConfiguration>(Arena*);
132template<> ::tensorflow::RunConfiguration_EnvVarsEntry_DoNotUse* Arena::CreateMaybeMessage<::tensorflow::RunConfiguration_EnvVarsEntry_DoNotUse>(Arena*);
133template<> ::tensorflow::TestResults* Arena::CreateMaybeMessage<::tensorflow::TestResults>(Arena*);
134PROTOBUF_NAMESPACE_CLOSE
135namespace tensorflow {
136
137enum TestResults_BenchmarkType : int {
138 TestResults_BenchmarkType_UNKNOWN = 0,
139 TestResults_BenchmarkType_CPP_MICROBENCHMARK = 1,
140 TestResults_BenchmarkType_PYTHON_BENCHMARK = 2,
141 TestResults_BenchmarkType_ANDROID_BENCHMARK = 3,
142 TestResults_BenchmarkType_EDGE_BENCHMARK = 4,
143 TestResults_BenchmarkType_IOS_BENCHMARK = 5,
144 TestResults_BenchmarkType_TestResults_BenchmarkType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
145 TestResults_BenchmarkType_TestResults_BenchmarkType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
146};
147bool TestResults_BenchmarkType_IsValid(int value);
148constexpr TestResults_BenchmarkType TestResults_BenchmarkType_BenchmarkType_MIN = TestResults_BenchmarkType_UNKNOWN;
149constexpr TestResults_BenchmarkType TestResults_BenchmarkType_BenchmarkType_MAX = TestResults_BenchmarkType_IOS_BENCHMARK;
150constexpr int TestResults_BenchmarkType_BenchmarkType_ARRAYSIZE = TestResults_BenchmarkType_BenchmarkType_MAX + 1;
151
152const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TestResults_BenchmarkType_descriptor();
153template<typename T>
154inline const std::string& TestResults_BenchmarkType_Name(T enum_t_value) {
155 static_assert(::std::is_same<T, TestResults_BenchmarkType>::value ||
156 ::std::is_integral<T>::value,
157 "Incorrect type passed to function TestResults_BenchmarkType_Name.");
158 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
159 TestResults_BenchmarkType_descriptor(), enum_t_value);
160}
161inline bool TestResults_BenchmarkType_Parse(
162 const std::string& name, TestResults_BenchmarkType* value) {
163 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TestResults_BenchmarkType>(
164 TestResults_BenchmarkType_descriptor(), name, value);
165}
166// ===================================================================
167
168class EntryValue :
169 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.EntryValue) */ {
170 public:
171 EntryValue();
172 virtual ~EntryValue();
173
174 EntryValue(const EntryValue& from);
175 EntryValue(EntryValue&& from) noexcept
176 : EntryValue() {
177 *this = ::std::move(from);
178 }
179
180 inline EntryValue& operator=(const EntryValue& from) {
181 CopyFrom(from);
182 return *this;
183 }
184 inline EntryValue& operator=(EntryValue&& from) noexcept {
185 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
186 if (this != &from) InternalSwap(&from);
187 } else {
188 CopyFrom(from);
189 }
190 return *this;
191 }
192
193 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
194 return GetArenaNoVirtual();
195 }
196 inline void* GetMaybeArenaPointer() const final {
197 return MaybeArenaPtr();
198 }
199 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
200 return GetDescriptor();
201 }
202 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
203 return GetMetadataStatic().descriptor;
204 }
205 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
206 return GetMetadataStatic().reflection;
207 }
208 static const EntryValue& default_instance();
209
210 enum KindCase {
211 kDoubleValue = 1,
212 kStringValue = 2,
213 KIND_NOT_SET = 0,
214 };
215
216 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
217 static inline const EntryValue* internal_default_instance() {
218 return reinterpret_cast<const EntryValue*>(
219 &_EntryValue_default_instance_);
220 }
221 static constexpr int kIndexInFileMessages =
222 0;
223
224 friend void swap(EntryValue& a, EntryValue& b) {
225 a.Swap(&b);
226 }
227 inline void Swap(EntryValue* other) {
228 if (other == this) return;
229 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
230 InternalSwap(other);
231 } else {
232 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
233 }
234 }
235 void UnsafeArenaSwap(EntryValue* other) {
236 if (other == this) return;
237 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
238 InternalSwap(other);
239 }
240
241 // implements Message ----------------------------------------------
242
243 inline EntryValue* New() const final {
244 return CreateMaybeMessage<EntryValue>(nullptr);
245 }
246
247 EntryValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
248 return CreateMaybeMessage<EntryValue>(arena);
249 }
250 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
251 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
252 void CopyFrom(const EntryValue& from);
253 void MergeFrom(const EntryValue& from);
254 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
255 bool IsInitialized() const final;
256
257 size_t ByteSizeLong() const final;
258 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
259 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
260 #else
261 bool MergePartialFromCodedStream(
262 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
263 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
264 void SerializeWithCachedSizes(
265 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
266 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
267 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
268 int GetCachedSize() const final { return _cached_size_.Get(); }
269
270 private:
271 inline void SharedCtor();
272 inline void SharedDtor();
273 void SetCachedSize(int size) const final;
274 void InternalSwap(EntryValue* other);
275 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
276 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
277 return "tensorflow.EntryValue";
278 }
279 protected:
280 explicit EntryValue(::PROTOBUF_NAMESPACE_ID::Arena* arena);
281 private:
282 static void ArenaDtor(void* object);
283 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
284 private:
285 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
286 return _internal_metadata_.arena();
287 }
288 inline void* MaybeArenaPtr() const {
289 return _internal_metadata_.raw_arena_ptr();
290 }
291 public:
292
293 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
294 private:
295 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
296 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
297 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
298 }
299
300 public:
301
302 // nested types ----------------------------------------------------
303
304 // accessors -------------------------------------------------------
305
306 enum : int {
307 kDoubleValueFieldNumber = 1,
308 kStringValueFieldNumber = 2,
309 };
310 // double double_value = 1;
311 private:
312 bool has_double_value() const;
313 public:
314 void clear_double_value();
315 double double_value() const;
316 void set_double_value(double value);
317
318 // string string_value = 2;
319 private:
320 bool has_string_value() const;
321 public:
322 void clear_string_value();
323 const std::string& string_value() const;
324 void set_string_value(const std::string& value);
325 void set_string_value(std::string&& value);
326 void set_string_value(const char* value);
327 void set_string_value(const char* value, size_t size);
328 std::string* mutable_string_value();
329 std::string* release_string_value();
330 void set_allocated_string_value(std::string* string_value);
331 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
332 " string fields are deprecated and will be removed in a"
333 " future release.")
334 std::string* unsafe_arena_release_string_value();
335 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
336 " string fields are deprecated and will be removed in a"
337 " future release.")
338 void unsafe_arena_set_allocated_string_value(
339 std::string* string_value);
340
341 void clear_kind();
342 KindCase kind_case() const;
343 // @@protoc_insertion_point(class_scope:tensorflow.EntryValue)
344 private:
345 class _Internal;
346 void set_has_double_value();
347 void set_has_string_value();
348
349 inline bool has_kind() const;
350 inline void clear_has_kind();
351
352 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
353 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
354 typedef void InternalArenaConstructable_;
355 typedef void DestructorSkippable_;
356 union KindUnion {
357 KindUnion() {}
358 double double_value_;
359 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
360 } kind_;
361 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
362 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
363
364 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
365};
366// -------------------------------------------------------------------
367
368class MetricEntry :
369 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MetricEntry) */ {
370 public:
371 MetricEntry();
372 virtual ~MetricEntry();
373
374 MetricEntry(const MetricEntry& from);
375 MetricEntry(MetricEntry&& from) noexcept
376 : MetricEntry() {
377 *this = ::std::move(from);
378 }
379
380 inline MetricEntry& operator=(const MetricEntry& from) {
381 CopyFrom(from);
382 return *this;
383 }
384 inline MetricEntry& operator=(MetricEntry&& from) noexcept {
385 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
386 if (this != &from) InternalSwap(&from);
387 } else {
388 CopyFrom(from);
389 }
390 return *this;
391 }
392
393 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
394 return GetArenaNoVirtual();
395 }
396 inline void* GetMaybeArenaPointer() const final {
397 return MaybeArenaPtr();
398 }
399 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
400 return GetDescriptor();
401 }
402 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
403 return GetMetadataStatic().descriptor;
404 }
405 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
406 return GetMetadataStatic().reflection;
407 }
408 static const MetricEntry& default_instance();
409
410 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
411 static inline const MetricEntry* internal_default_instance() {
412 return reinterpret_cast<const MetricEntry*>(
413 &_MetricEntry_default_instance_);
414 }
415 static constexpr int kIndexInFileMessages =
416 1;
417
418 friend void swap(MetricEntry& a, MetricEntry& b) {
419 a.Swap(&b);
420 }
421 inline void Swap(MetricEntry* other) {
422 if (other == this) return;
423 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
424 InternalSwap(other);
425 } else {
426 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
427 }
428 }
429 void UnsafeArenaSwap(MetricEntry* other) {
430 if (other == this) return;
431 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
432 InternalSwap(other);
433 }
434
435 // implements Message ----------------------------------------------
436
437 inline MetricEntry* New() const final {
438 return CreateMaybeMessage<MetricEntry>(nullptr);
439 }
440
441 MetricEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
442 return CreateMaybeMessage<MetricEntry>(arena);
443 }
444 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
445 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
446 void CopyFrom(const MetricEntry& from);
447 void MergeFrom(const MetricEntry& from);
448 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
449 bool IsInitialized() const final;
450
451 size_t ByteSizeLong() const final;
452 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
453 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
454 #else
455 bool MergePartialFromCodedStream(
456 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
457 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
458 void SerializeWithCachedSizes(
459 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
460 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
461 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
462 int GetCachedSize() const final { return _cached_size_.Get(); }
463
464 private:
465 inline void SharedCtor();
466 inline void SharedDtor();
467 void SetCachedSize(int size) const final;
468 void InternalSwap(MetricEntry* other);
469 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
470 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
471 return "tensorflow.MetricEntry";
472 }
473 protected:
474 explicit MetricEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
475 private:
476 static void ArenaDtor(void* object);
477 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
478 private:
479 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
480 return _internal_metadata_.arena();
481 }
482 inline void* MaybeArenaPtr() const {
483 return _internal_metadata_.raw_arena_ptr();
484 }
485 public:
486
487 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
488 private:
489 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
490 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
491 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
492 }
493
494 public:
495
496 // nested types ----------------------------------------------------
497
498 // accessors -------------------------------------------------------
499
500 enum : int {
501 kNameFieldNumber = 1,
502 kMinValueFieldNumber = 3,
503 kMaxValueFieldNumber = 4,
504 kValueFieldNumber = 2,
505 };
506 // string name = 1;
507 void clear_name();
508 const std::string& name() const;
509 void set_name(const std::string& value);
510 void set_name(std::string&& value);
511 void set_name(const char* value);
512 void set_name(const char* value, size_t size);
513 std::string* mutable_name();
514 std::string* release_name();
515 void set_allocated_name(std::string* name);
516 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
517 " string fields are deprecated and will be removed in a"
518 " future release.")
519 std::string* unsafe_arena_release_name();
520 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
521 " string fields are deprecated and will be removed in a"
522 " future release.")
523 void unsafe_arena_set_allocated_name(
524 std::string* name);
525
526 // .google.protobuf.DoubleValue min_value = 3;
527 bool has_min_value() const;
528 void clear_min_value();
529 const PROTOBUF_NAMESPACE_ID::DoubleValue& min_value() const;
530 PROTOBUF_NAMESPACE_ID::DoubleValue* release_min_value();
531 PROTOBUF_NAMESPACE_ID::DoubleValue* mutable_min_value();
532 void set_allocated_min_value(PROTOBUF_NAMESPACE_ID::DoubleValue* min_value);
533 void unsafe_arena_set_allocated_min_value(
534 PROTOBUF_NAMESPACE_ID::DoubleValue* min_value);
535 PROTOBUF_NAMESPACE_ID::DoubleValue* unsafe_arena_release_min_value();
536
537 // .google.protobuf.DoubleValue max_value = 4;
538 bool has_max_value() const;
539 void clear_max_value();
540 const PROTOBUF_NAMESPACE_ID::DoubleValue& max_value() const;
541 PROTOBUF_NAMESPACE_ID::DoubleValue* release_max_value();
542 PROTOBUF_NAMESPACE_ID::DoubleValue* mutable_max_value();
543 void set_allocated_max_value(PROTOBUF_NAMESPACE_ID::DoubleValue* max_value);
544 void unsafe_arena_set_allocated_max_value(
545 PROTOBUF_NAMESPACE_ID::DoubleValue* max_value);
546 PROTOBUF_NAMESPACE_ID::DoubleValue* unsafe_arena_release_max_value();
547
548 // double value = 2;
549 void clear_value();
550 double value() const;
551 void set_value(double value);
552
553 // @@protoc_insertion_point(class_scope:tensorflow.MetricEntry)
554 private:
555 class _Internal;
556
557 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
558 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
559 typedef void InternalArenaConstructable_;
560 typedef void DestructorSkippable_;
561 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
562 PROTOBUF_NAMESPACE_ID::DoubleValue* min_value_;
563 PROTOBUF_NAMESPACE_ID::DoubleValue* max_value_;
564 double value_;
565 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
566 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
567};
568// -------------------------------------------------------------------
569
570class BenchmarkEntry_ExtrasEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<BenchmarkEntry_ExtrasEntry_DoNotUse,
571 std::string, ::tensorflow::EntryValue,
572 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
573 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
574 0 > {
575public:
576 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<BenchmarkEntry_ExtrasEntry_DoNotUse,
577 std::string, ::tensorflow::EntryValue,
578 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
579 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
580 0 > SuperType;
581 BenchmarkEntry_ExtrasEntry_DoNotUse();
582 BenchmarkEntry_ExtrasEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
583 void MergeFrom(const BenchmarkEntry_ExtrasEntry_DoNotUse& other);
584 static const BenchmarkEntry_ExtrasEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const BenchmarkEntry_ExtrasEntry_DoNotUse*>(&_BenchmarkEntry_ExtrasEntry_DoNotUse_default_instance_); }
585 static bool ValidateKey(std::string* s) {
586 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.BenchmarkEntry.ExtrasEntry.key");
587 }
588 static bool ValidateValue(void*) { return true; }
589 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
590 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
591 private:
592 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
593 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
594 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[2];
595 }
596
597 public:
598};
599
600// -------------------------------------------------------------------
601
602class BenchmarkEntry :
603 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BenchmarkEntry) */ {
604 public:
605 BenchmarkEntry();
606 virtual ~BenchmarkEntry();
607
608 BenchmarkEntry(const BenchmarkEntry& from);
609 BenchmarkEntry(BenchmarkEntry&& from) noexcept
610 : BenchmarkEntry() {
611 *this = ::std::move(from);
612 }
613
614 inline BenchmarkEntry& operator=(const BenchmarkEntry& from) {
615 CopyFrom(from);
616 return *this;
617 }
618 inline BenchmarkEntry& operator=(BenchmarkEntry&& from) noexcept {
619 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
620 if (this != &from) InternalSwap(&from);
621 } else {
622 CopyFrom(from);
623 }
624 return *this;
625 }
626
627 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
628 return GetArenaNoVirtual();
629 }
630 inline void* GetMaybeArenaPointer() const final {
631 return MaybeArenaPtr();
632 }
633 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
634 return GetDescriptor();
635 }
636 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
637 return GetMetadataStatic().descriptor;
638 }
639 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
640 return GetMetadataStatic().reflection;
641 }
642 static const BenchmarkEntry& default_instance();
643
644 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
645 static inline const BenchmarkEntry* internal_default_instance() {
646 return reinterpret_cast<const BenchmarkEntry*>(
647 &_BenchmarkEntry_default_instance_);
648 }
649 static constexpr int kIndexInFileMessages =
650 3;
651
652 friend void swap(BenchmarkEntry& a, BenchmarkEntry& b) {
653 a.Swap(&b);
654 }
655 inline void Swap(BenchmarkEntry* other) {
656 if (other == this) return;
657 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
658 InternalSwap(other);
659 } else {
660 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
661 }
662 }
663 void UnsafeArenaSwap(BenchmarkEntry* other) {
664 if (other == this) return;
665 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
666 InternalSwap(other);
667 }
668
669 // implements Message ----------------------------------------------
670
671 inline BenchmarkEntry* New() const final {
672 return CreateMaybeMessage<BenchmarkEntry>(nullptr);
673 }
674
675 BenchmarkEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
676 return CreateMaybeMessage<BenchmarkEntry>(arena);
677 }
678 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
679 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
680 void CopyFrom(const BenchmarkEntry& from);
681 void MergeFrom(const BenchmarkEntry& from);
682 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
683 bool IsInitialized() const final;
684
685 size_t ByteSizeLong() const final;
686 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
687 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
688 #else
689 bool MergePartialFromCodedStream(
690 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
691 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
692 void SerializeWithCachedSizes(
693 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
694 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
695 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
696 int GetCachedSize() const final { return _cached_size_.Get(); }
697
698 private:
699 inline void SharedCtor();
700 inline void SharedDtor();
701 void SetCachedSize(int size) const final;
702 void InternalSwap(BenchmarkEntry* other);
703 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
704 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
705 return "tensorflow.BenchmarkEntry";
706 }
707 protected:
708 explicit BenchmarkEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena);
709 private:
710 static void ArenaDtor(void* object);
711 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
712 private:
713 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
714 return _internal_metadata_.arena();
715 }
716 inline void* MaybeArenaPtr() const {
717 return _internal_metadata_.raw_arena_ptr();
718 }
719 public:
720
721 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
722 private:
723 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
724 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
725 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
726 }
727
728 public:
729
730 // nested types ----------------------------------------------------
731
732
733 // accessors -------------------------------------------------------
734
735 enum : int {
736 kExtrasFieldNumber = 6,
737 kMetricsFieldNumber = 7,
738 kNameFieldNumber = 1,
739 kItersFieldNumber = 2,
740 kCpuTimeFieldNumber = 3,
741 kWallTimeFieldNumber = 4,
742 kThroughputFieldNumber = 5,
743 };
744 // map<string, .tensorflow.EntryValue> extras = 6;
745 int extras_size() const;
746 void clear_extras();
747 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
748 extras() const;
749 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
750 mutable_extras();
751
752 // repeated .tensorflow.MetricEntry metrics = 7;
753 int metrics_size() const;
754 void clear_metrics();
755 ::tensorflow::MetricEntry* mutable_metrics(int index);
756 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >*
757 mutable_metrics();
758 const ::tensorflow::MetricEntry& metrics(int index) const;
759 ::tensorflow::MetricEntry* add_metrics();
760 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >&
761 metrics() const;
762
763 // string name = 1;
764 void clear_name();
765 const std::string& name() const;
766 void set_name(const std::string& value);
767 void set_name(std::string&& value);
768 void set_name(const char* value);
769 void set_name(const char* value, size_t size);
770 std::string* mutable_name();
771 std::string* release_name();
772 void set_allocated_name(std::string* name);
773 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
774 " string fields are deprecated and will be removed in a"
775 " future release.")
776 std::string* unsafe_arena_release_name();
777 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
778 " string fields are deprecated and will be removed in a"
779 " future release.")
780 void unsafe_arena_set_allocated_name(
781 std::string* name);
782
783 // int64 iters = 2;
784 void clear_iters();
785 ::PROTOBUF_NAMESPACE_ID::int64 iters() const;
786 void set_iters(::PROTOBUF_NAMESPACE_ID::int64 value);
787
788 // double cpu_time = 3;
789 void clear_cpu_time();
790 double cpu_time() const;
791 void set_cpu_time(double value);
792
793 // double wall_time = 4;
794 void clear_wall_time();
795 double wall_time() const;
796 void set_wall_time(double value);
797
798 // double throughput = 5;
799 void clear_throughput();
800 double throughput() const;
801 void set_throughput(double value);
802
803 // @@protoc_insertion_point(class_scope:tensorflow.BenchmarkEntry)
804 private:
805 class _Internal;
806
807 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
808 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
809 typedef void InternalArenaConstructable_;
810 typedef void DestructorSkippable_;
811 ::PROTOBUF_NAMESPACE_ID::internal::MapField<
812 BenchmarkEntry_ExtrasEntry_DoNotUse,
813 std::string, ::tensorflow::EntryValue,
814 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
815 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE,
816 0 > extras_;
817 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry > metrics_;
818 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
819 ::PROTOBUF_NAMESPACE_ID::int64 iters_;
820 double cpu_time_;
821 double wall_time_;
822 double throughput_;
823 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
824 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
825};
826// -------------------------------------------------------------------
827
828class BenchmarkEntries :
829 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BenchmarkEntries) */ {
830 public:
831 BenchmarkEntries();
832 virtual ~BenchmarkEntries();
833
834 BenchmarkEntries(const BenchmarkEntries& from);
835 BenchmarkEntries(BenchmarkEntries&& from) noexcept
836 : BenchmarkEntries() {
837 *this = ::std::move(from);
838 }
839
840 inline BenchmarkEntries& operator=(const BenchmarkEntries& from) {
841 CopyFrom(from);
842 return *this;
843 }
844 inline BenchmarkEntries& operator=(BenchmarkEntries&& from) noexcept {
845 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
846 if (this != &from) InternalSwap(&from);
847 } else {
848 CopyFrom(from);
849 }
850 return *this;
851 }
852
853 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
854 return GetArenaNoVirtual();
855 }
856 inline void* GetMaybeArenaPointer() const final {
857 return MaybeArenaPtr();
858 }
859 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
860 return GetDescriptor();
861 }
862 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
863 return GetMetadataStatic().descriptor;
864 }
865 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
866 return GetMetadataStatic().reflection;
867 }
868 static const BenchmarkEntries& default_instance();
869
870 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
871 static inline const BenchmarkEntries* internal_default_instance() {
872 return reinterpret_cast<const BenchmarkEntries*>(
873 &_BenchmarkEntries_default_instance_);
874 }
875 static constexpr int kIndexInFileMessages =
876 4;
877
878 friend void swap(BenchmarkEntries& a, BenchmarkEntries& b) {
879 a.Swap(&b);
880 }
881 inline void Swap(BenchmarkEntries* other) {
882 if (other == this) return;
883 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
884 InternalSwap(other);
885 } else {
886 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
887 }
888 }
889 void UnsafeArenaSwap(BenchmarkEntries* other) {
890 if (other == this) return;
891 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
892 InternalSwap(other);
893 }
894
895 // implements Message ----------------------------------------------
896
897 inline BenchmarkEntries* New() const final {
898 return CreateMaybeMessage<BenchmarkEntries>(nullptr);
899 }
900
901 BenchmarkEntries* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
902 return CreateMaybeMessage<BenchmarkEntries>(arena);
903 }
904 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
905 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
906 void CopyFrom(const BenchmarkEntries& from);
907 void MergeFrom(const BenchmarkEntries& from);
908 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
909 bool IsInitialized() const final;
910
911 size_t ByteSizeLong() const final;
912 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
913 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
914 #else
915 bool MergePartialFromCodedStream(
916 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
917 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
918 void SerializeWithCachedSizes(
919 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
920 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
921 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
922 int GetCachedSize() const final { return _cached_size_.Get(); }
923
924 private:
925 inline void SharedCtor();
926 inline void SharedDtor();
927 void SetCachedSize(int size) const final;
928 void InternalSwap(BenchmarkEntries* other);
929 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
930 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
931 return "tensorflow.BenchmarkEntries";
932 }
933 protected:
934 explicit BenchmarkEntries(::PROTOBUF_NAMESPACE_ID::Arena* arena);
935 private:
936 static void ArenaDtor(void* object);
937 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
938 private:
939 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
940 return _internal_metadata_.arena();
941 }
942 inline void* MaybeArenaPtr() const {
943 return _internal_metadata_.raw_arena_ptr();
944 }
945 public:
946
947 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
948 private:
949 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
950 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
951 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
952 }
953
954 public:
955
956 // nested types ----------------------------------------------------
957
958 // accessors -------------------------------------------------------
959
960 enum : int {
961 kEntryFieldNumber = 1,
962 };
963 // repeated .tensorflow.BenchmarkEntry entry = 1;
964 int entry_size() const;
965 void clear_entry();
966 ::tensorflow::BenchmarkEntry* mutable_entry(int index);
967 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >*
968 mutable_entry();
969 const ::tensorflow::BenchmarkEntry& entry(int index) const;
970 ::tensorflow::BenchmarkEntry* add_entry();
971 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >&
972 entry() const;
973
974 // @@protoc_insertion_point(class_scope:tensorflow.BenchmarkEntries)
975 private:
976 class _Internal;
977
978 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
979 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
980 typedef void InternalArenaConstructable_;
981 typedef void DestructorSkippable_;
982 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry > entry_;
983 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
984 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
985};
986// -------------------------------------------------------------------
987
988class BuildConfiguration :
989 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BuildConfiguration) */ {
990 public:
991 BuildConfiguration();
992 virtual ~BuildConfiguration();
993
994 BuildConfiguration(const BuildConfiguration& from);
995 BuildConfiguration(BuildConfiguration&& from) noexcept
996 : BuildConfiguration() {
997 *this = ::std::move(from);
998 }
999
1000 inline BuildConfiguration& operator=(const BuildConfiguration& from) {
1001 CopyFrom(from);
1002 return *this;
1003 }
1004 inline BuildConfiguration& operator=(BuildConfiguration&& from) noexcept {
1005 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1006 if (this != &from) InternalSwap(&from);
1007 } else {
1008 CopyFrom(from);
1009 }
1010 return *this;
1011 }
1012
1013 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1014 return GetArenaNoVirtual();
1015 }
1016 inline void* GetMaybeArenaPointer() const final {
1017 return MaybeArenaPtr();
1018 }
1019 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1020 return GetDescriptor();
1021 }
1022 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1023 return GetMetadataStatic().descriptor;
1024 }
1025 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1026 return GetMetadataStatic().reflection;
1027 }
1028 static const BuildConfiguration& default_instance();
1029
1030 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1031 static inline const BuildConfiguration* internal_default_instance() {
1032 return reinterpret_cast<const BuildConfiguration*>(
1033 &_BuildConfiguration_default_instance_);
1034 }
1035 static constexpr int kIndexInFileMessages =
1036 5;
1037
1038 friend void swap(BuildConfiguration& a, BuildConfiguration& b) {
1039 a.Swap(&b);
1040 }
1041 inline void Swap(BuildConfiguration* other) {
1042 if (other == this) return;
1043 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1044 InternalSwap(other);
1045 } else {
1046 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1047 }
1048 }
1049 void UnsafeArenaSwap(BuildConfiguration* other) {
1050 if (other == this) return;
1051 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1052 InternalSwap(other);
1053 }
1054
1055 // implements Message ----------------------------------------------
1056
1057 inline BuildConfiguration* New() const final {
1058 return CreateMaybeMessage<BuildConfiguration>(nullptr);
1059 }
1060
1061 BuildConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1062 return CreateMaybeMessage<BuildConfiguration>(arena);
1063 }
1064 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1065 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1066 void CopyFrom(const BuildConfiguration& from);
1067 void MergeFrom(const BuildConfiguration& from);
1068 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1069 bool IsInitialized() const final;
1070
1071 size_t ByteSizeLong() const final;
1072 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1073 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1074 #else
1075 bool MergePartialFromCodedStream(
1076 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1077 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1078 void SerializeWithCachedSizes(
1079 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1080 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1081 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1082 int GetCachedSize() const final { return _cached_size_.Get(); }
1083
1084 private:
1085 inline void SharedCtor();
1086 inline void SharedDtor();
1087 void SetCachedSize(int size) const final;
1088 void InternalSwap(BuildConfiguration* other);
1089 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1090 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1091 return "tensorflow.BuildConfiguration";
1092 }
1093 protected:
1094 explicit BuildConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1095 private:
1096 static void ArenaDtor(void* object);
1097 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1098 private:
1099 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1100 return _internal_metadata_.arena();
1101 }
1102 inline void* MaybeArenaPtr() const {
1103 return _internal_metadata_.raw_arena_ptr();
1104 }
1105 public:
1106
1107 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1108 private:
1109 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1110 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1111 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
1112 }
1113
1114 public:
1115
1116 // nested types ----------------------------------------------------
1117
1118 // accessors -------------------------------------------------------
1119
1120 enum : int {
1121 kCcFlagsFieldNumber = 2,
1122 kOptsFieldNumber = 3,
1123 kModeFieldNumber = 1,
1124 };
1125 // repeated string cc_flags = 2;
1126 int cc_flags_size() const;
1127 void clear_cc_flags();
1128 const std::string& cc_flags(int index) const;
1129 std::string* mutable_cc_flags(int index);
1130 void set_cc_flags(int index, const std::string& value);
1131 void set_cc_flags(int index, std::string&& value);
1132 void set_cc_flags(int index, const char* value);
1133 void set_cc_flags(int index, const char* value, size_t size);
1134 std::string* add_cc_flags();
1135 void add_cc_flags(const std::string& value);
1136 void add_cc_flags(std::string&& value);
1137 void add_cc_flags(const char* value);
1138 void add_cc_flags(const char* value, size_t size);
1139 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& cc_flags() const;
1140 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_cc_flags();
1141
1142 // repeated string opts = 3;
1143 int opts_size() const;
1144 void clear_opts();
1145 const std::string& opts(int index) const;
1146 std::string* mutable_opts(int index);
1147 void set_opts(int index, const std::string& value);
1148 void set_opts(int index, std::string&& value);
1149 void set_opts(int index, const char* value);
1150 void set_opts(int index, const char* value, size_t size);
1151 std::string* add_opts();
1152 void add_opts(const std::string& value);
1153 void add_opts(std::string&& value);
1154 void add_opts(const char* value);
1155 void add_opts(const char* value, size_t size);
1156 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& opts() const;
1157 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_opts();
1158
1159 // string mode = 1;
1160 void clear_mode();
1161 const std::string& mode() const;
1162 void set_mode(const std::string& value);
1163 void set_mode(std::string&& value);
1164 void set_mode(const char* value);
1165 void set_mode(const char* value, size_t size);
1166 std::string* mutable_mode();
1167 std::string* release_mode();
1168 void set_allocated_mode(std::string* mode);
1169 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1170 " string fields are deprecated and will be removed in a"
1171 " future release.")
1172 std::string* unsafe_arena_release_mode();
1173 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1174 " string fields are deprecated and will be removed in a"
1175 " future release.")
1176 void unsafe_arena_set_allocated_mode(
1177 std::string* mode);
1178
1179 // @@protoc_insertion_point(class_scope:tensorflow.BuildConfiguration)
1180 private:
1181 class _Internal;
1182
1183 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1184 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1185 typedef void InternalArenaConstructable_;
1186 typedef void DestructorSkippable_;
1187 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> cc_flags_;
1188 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> opts_;
1189 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mode_;
1190 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1191 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
1192};
1193// -------------------------------------------------------------------
1194
1195class CommitId :
1196 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CommitId) */ {
1197 public:
1198 CommitId();
1199 virtual ~CommitId();
1200
1201 CommitId(const CommitId& from);
1202 CommitId(CommitId&& from) noexcept
1203 : CommitId() {
1204 *this = ::std::move(from);
1205 }
1206
1207 inline CommitId& operator=(const CommitId& from) {
1208 CopyFrom(from);
1209 return *this;
1210 }
1211 inline CommitId& operator=(CommitId&& from) noexcept {
1212 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1213 if (this != &from) InternalSwap(&from);
1214 } else {
1215 CopyFrom(from);
1216 }
1217 return *this;
1218 }
1219
1220 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1221 return GetArenaNoVirtual();
1222 }
1223 inline void* GetMaybeArenaPointer() const final {
1224 return MaybeArenaPtr();
1225 }
1226 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1227 return GetDescriptor();
1228 }
1229 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1230 return GetMetadataStatic().descriptor;
1231 }
1232 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1233 return GetMetadataStatic().reflection;
1234 }
1235 static const CommitId& default_instance();
1236
1237 enum KindCase {
1238 kChangelist = 1,
1239 kHash = 2,
1240 KIND_NOT_SET = 0,
1241 };
1242
1243 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1244 static inline const CommitId* internal_default_instance() {
1245 return reinterpret_cast<const CommitId*>(
1246 &_CommitId_default_instance_);
1247 }
1248 static constexpr int kIndexInFileMessages =
1249 6;
1250
1251 friend void swap(CommitId& a, CommitId& b) {
1252 a.Swap(&b);
1253 }
1254 inline void Swap(CommitId* other) {
1255 if (other == this) return;
1256 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1257 InternalSwap(other);
1258 } else {
1259 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1260 }
1261 }
1262 void UnsafeArenaSwap(CommitId* other) {
1263 if (other == this) return;
1264 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1265 InternalSwap(other);
1266 }
1267
1268 // implements Message ----------------------------------------------
1269
1270 inline CommitId* New() const final {
1271 return CreateMaybeMessage<CommitId>(nullptr);
1272 }
1273
1274 CommitId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1275 return CreateMaybeMessage<CommitId>(arena);
1276 }
1277 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1278 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1279 void CopyFrom(const CommitId& from);
1280 void MergeFrom(const CommitId& from);
1281 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1282 bool IsInitialized() const final;
1283
1284 size_t ByteSizeLong() const final;
1285 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1286 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1287 #else
1288 bool MergePartialFromCodedStream(
1289 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1290 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1291 void SerializeWithCachedSizes(
1292 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1293 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1294 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1295 int GetCachedSize() const final { return _cached_size_.Get(); }
1296
1297 private:
1298 inline void SharedCtor();
1299 inline void SharedDtor();
1300 void SetCachedSize(int size) const final;
1301 void InternalSwap(CommitId* other);
1302 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1303 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1304 return "tensorflow.CommitId";
1305 }
1306 protected:
1307 explicit CommitId(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1308 private:
1309 static void ArenaDtor(void* object);
1310 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1311 private:
1312 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1313 return _internal_metadata_.arena();
1314 }
1315 inline void* MaybeArenaPtr() const {
1316 return _internal_metadata_.raw_arena_ptr();
1317 }
1318 public:
1319
1320 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1321 private:
1322 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1323 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1324 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
1325 }
1326
1327 public:
1328
1329 // nested types ----------------------------------------------------
1330
1331 // accessors -------------------------------------------------------
1332
1333 enum : int {
1334 kSnapshotFieldNumber = 3,
1335 kPendingChangelistFieldNumber = 4,
1336 kChangelistFieldNumber = 1,
1337 kHashFieldNumber = 2,
1338 };
1339 // string snapshot = 3;
1340 void clear_snapshot();
1341 const std::string& snapshot() const;
1342 void set_snapshot(const std::string& value);
1343 void set_snapshot(std::string&& value);
1344 void set_snapshot(const char* value);
1345 void set_snapshot(const char* value, size_t size);
1346 std::string* mutable_snapshot();
1347 std::string* release_snapshot();
1348 void set_allocated_snapshot(std::string* snapshot);
1349 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1350 " string fields are deprecated and will be removed in a"
1351 " future release.")
1352 std::string* unsafe_arena_release_snapshot();
1353 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1354 " string fields are deprecated and will be removed in a"
1355 " future release.")
1356 void unsafe_arena_set_allocated_snapshot(
1357 std::string* snapshot);
1358
1359 // int64 pending_changelist = 4;
1360 void clear_pending_changelist();
1361 ::PROTOBUF_NAMESPACE_ID::int64 pending_changelist() const;
1362 void set_pending_changelist(::PROTOBUF_NAMESPACE_ID::int64 value);
1363
1364 // int64 changelist = 1;
1365 private:
1366 bool has_changelist() const;
1367 public:
1368 void clear_changelist();
1369 ::PROTOBUF_NAMESPACE_ID::int64 changelist() const;
1370 void set_changelist(::PROTOBUF_NAMESPACE_ID::int64 value);
1371
1372 // string hash = 2;
1373 private:
1374 bool has_hash() const;
1375 public:
1376 void clear_hash();
1377 const std::string& hash() const;
1378 void set_hash(const std::string& value);
1379 void set_hash(std::string&& value);
1380 void set_hash(const char* value);
1381 void set_hash(const char* value, size_t size);
1382 std::string* mutable_hash();
1383 std::string* release_hash();
1384 void set_allocated_hash(std::string* hash);
1385 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1386 " string fields are deprecated and will be removed in a"
1387 " future release.")
1388 std::string* unsafe_arena_release_hash();
1389 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1390 " string fields are deprecated and will be removed in a"
1391 " future release.")
1392 void unsafe_arena_set_allocated_hash(
1393 std::string* hash);
1394
1395 void clear_kind();
1396 KindCase kind_case() const;
1397 // @@protoc_insertion_point(class_scope:tensorflow.CommitId)
1398 private:
1399 class _Internal;
1400 void set_has_changelist();
1401 void set_has_hash();
1402
1403 inline bool has_kind() const;
1404 inline void clear_has_kind();
1405
1406 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1407 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1408 typedef void InternalArenaConstructable_;
1409 typedef void DestructorSkippable_;
1410 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr snapshot_;
1411 ::PROTOBUF_NAMESPACE_ID::int64 pending_changelist_;
1412 union KindUnion {
1413 KindUnion() {}
1414 ::PROTOBUF_NAMESPACE_ID::int64 changelist_;
1415 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hash_;
1416 } kind_;
1417 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1418 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
1419
1420 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
1421};
1422// -------------------------------------------------------------------
1423
1424class CPUInfo_CacheSizeEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CPUInfo_CacheSizeEntry_DoNotUse,
1425 std::string, ::PROTOBUF_NAMESPACE_ID::int64,
1426 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1427 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
1428 0 > {
1429public:
1430 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<CPUInfo_CacheSizeEntry_DoNotUse,
1431 std::string, ::PROTOBUF_NAMESPACE_ID::int64,
1432 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1433 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
1434 0 > SuperType;
1435 CPUInfo_CacheSizeEntry_DoNotUse();
1436 CPUInfo_CacheSizeEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1437 void MergeFrom(const CPUInfo_CacheSizeEntry_DoNotUse& other);
1438 static const CPUInfo_CacheSizeEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const CPUInfo_CacheSizeEntry_DoNotUse*>(&_CPUInfo_CacheSizeEntry_DoNotUse_default_instance_); }
1439 static bool ValidateKey(std::string* s) {
1440 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.CPUInfo.CacheSizeEntry.key");
1441 }
1442 static bool ValidateValue(void*) { return true; }
1443 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
1444 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1445 private:
1446 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1447 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1448 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[7];
1449 }
1450
1451 public:
1452};
1453
1454// -------------------------------------------------------------------
1455
1456class CPUInfo :
1457 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CPUInfo) */ {
1458 public:
1459 CPUInfo();
1460 virtual ~CPUInfo();
1461
1462 CPUInfo(const CPUInfo& from);
1463 CPUInfo(CPUInfo&& from) noexcept
1464 : CPUInfo() {
1465 *this = ::std::move(from);
1466 }
1467
1468 inline CPUInfo& operator=(const CPUInfo& from) {
1469 CopyFrom(from);
1470 return *this;
1471 }
1472 inline CPUInfo& operator=(CPUInfo&& from) noexcept {
1473 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1474 if (this != &from) InternalSwap(&from);
1475 } else {
1476 CopyFrom(from);
1477 }
1478 return *this;
1479 }
1480
1481 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1482 return GetArenaNoVirtual();
1483 }
1484 inline void* GetMaybeArenaPointer() const final {
1485 return MaybeArenaPtr();
1486 }
1487 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1488 return GetDescriptor();
1489 }
1490 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1491 return GetMetadataStatic().descriptor;
1492 }
1493 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1494 return GetMetadataStatic().reflection;
1495 }
1496 static const CPUInfo& default_instance();
1497
1498 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1499 static inline const CPUInfo* internal_default_instance() {
1500 return reinterpret_cast<const CPUInfo*>(
1501 &_CPUInfo_default_instance_);
1502 }
1503 static constexpr int kIndexInFileMessages =
1504 8;
1505
1506 friend void swap(CPUInfo& a, CPUInfo& b) {
1507 a.Swap(&b);
1508 }
1509 inline void Swap(CPUInfo* other) {
1510 if (other == this) return;
1511 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1512 InternalSwap(other);
1513 } else {
1514 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1515 }
1516 }
1517 void UnsafeArenaSwap(CPUInfo* other) {
1518 if (other == this) return;
1519 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1520 InternalSwap(other);
1521 }
1522
1523 // implements Message ----------------------------------------------
1524
1525 inline CPUInfo* New() const final {
1526 return CreateMaybeMessage<CPUInfo>(nullptr);
1527 }
1528
1529 CPUInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1530 return CreateMaybeMessage<CPUInfo>(arena);
1531 }
1532 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1533 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1534 void CopyFrom(const CPUInfo& from);
1535 void MergeFrom(const CPUInfo& from);
1536 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1537 bool IsInitialized() const final;
1538
1539 size_t ByteSizeLong() const final;
1540 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1541 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1542 #else
1543 bool MergePartialFromCodedStream(
1544 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1545 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1546 void SerializeWithCachedSizes(
1547 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1548 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1549 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1550 int GetCachedSize() const final { return _cached_size_.Get(); }
1551
1552 private:
1553 inline void SharedCtor();
1554 inline void SharedDtor();
1555 void SetCachedSize(int size) const final;
1556 void InternalSwap(CPUInfo* other);
1557 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1558 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1559 return "tensorflow.CPUInfo";
1560 }
1561 protected:
1562 explicit CPUInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1563 private:
1564 static void ArenaDtor(void* object);
1565 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1566 private:
1567 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1568 return _internal_metadata_.arena();
1569 }
1570 inline void* MaybeArenaPtr() const {
1571 return _internal_metadata_.raw_arena_ptr();
1572 }
1573 public:
1574
1575 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1576 private:
1577 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1578 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1579 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
1580 }
1581
1582 public:
1583
1584 // nested types ----------------------------------------------------
1585
1586
1587 // accessors -------------------------------------------------------
1588
1589 enum : int {
1590 kCacheSizeFieldNumber = 6,
1591 kCpuInfoFieldNumber = 4,
1592 kCpuGovernorFieldNumber = 5,
1593 kNumCoresFieldNumber = 1,
1594 kNumCoresAllowedFieldNumber = 2,
1595 kMhzPerCpuFieldNumber = 3,
1596 };
1597 // map<string, int64> cache_size = 6;
1598 int cache_size_size() const;
1599 void clear_cache_size();
1600 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int64 >&
1601 cache_size() const;
1602 ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int64 >*
1603 mutable_cache_size();
1604
1605 // string cpu_info = 4;
1606 void clear_cpu_info();
1607 const std::string& cpu_info() const;
1608 void set_cpu_info(const std::string& value);
1609 void set_cpu_info(std::string&& value);
1610 void set_cpu_info(const char* value);
1611 void set_cpu_info(const char* value, size_t size);
1612 std::string* mutable_cpu_info();
1613 std::string* release_cpu_info();
1614 void set_allocated_cpu_info(std::string* cpu_info);
1615 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1616 " string fields are deprecated and will be removed in a"
1617 " future release.")
1618 std::string* unsafe_arena_release_cpu_info();
1619 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1620 " string fields are deprecated and will be removed in a"
1621 " future release.")
1622 void unsafe_arena_set_allocated_cpu_info(
1623 std::string* cpu_info);
1624
1625 // string cpu_governor = 5;
1626 void clear_cpu_governor();
1627 const std::string& cpu_governor() const;
1628 void set_cpu_governor(const std::string& value);
1629 void set_cpu_governor(std::string&& value);
1630 void set_cpu_governor(const char* value);
1631 void set_cpu_governor(const char* value, size_t size);
1632 std::string* mutable_cpu_governor();
1633 std::string* release_cpu_governor();
1634 void set_allocated_cpu_governor(std::string* cpu_governor);
1635 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1636 " string fields are deprecated and will be removed in a"
1637 " future release.")
1638 std::string* unsafe_arena_release_cpu_governor();
1639 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1640 " string fields are deprecated and will be removed in a"
1641 " future release.")
1642 void unsafe_arena_set_allocated_cpu_governor(
1643 std::string* cpu_governor);
1644
1645 // int64 num_cores = 1;
1646 void clear_num_cores();
1647 ::PROTOBUF_NAMESPACE_ID::int64 num_cores() const;
1648 void set_num_cores(::PROTOBUF_NAMESPACE_ID::int64 value);
1649
1650 // int64 num_cores_allowed = 2;
1651 void clear_num_cores_allowed();
1652 ::PROTOBUF_NAMESPACE_ID::int64 num_cores_allowed() const;
1653 void set_num_cores_allowed(::PROTOBUF_NAMESPACE_ID::int64 value);
1654
1655 // double mhz_per_cpu = 3;
1656 void clear_mhz_per_cpu();
1657 double mhz_per_cpu() const;
1658 void set_mhz_per_cpu(double value);
1659
1660 // @@protoc_insertion_point(class_scope:tensorflow.CPUInfo)
1661 private:
1662 class _Internal;
1663
1664 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1665 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1666 typedef void InternalArenaConstructable_;
1667 typedef void DestructorSkippable_;
1668 ::PROTOBUF_NAMESPACE_ID::internal::MapField<
1669 CPUInfo_CacheSizeEntry_DoNotUse,
1670 std::string, ::PROTOBUF_NAMESPACE_ID::int64,
1671 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1672 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64,
1673 0 > cache_size_;
1674 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_info_;
1675 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cpu_governor_;
1676 ::PROTOBUF_NAMESPACE_ID::int64 num_cores_;
1677 ::PROTOBUF_NAMESPACE_ID::int64 num_cores_allowed_;
1678 double mhz_per_cpu_;
1679 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1680 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
1681};
1682// -------------------------------------------------------------------
1683
1684class MemoryInfo :
1685 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MemoryInfo) */ {
1686 public:
1687 MemoryInfo();
1688 virtual ~MemoryInfo();
1689
1690 MemoryInfo(const MemoryInfo& from);
1691 MemoryInfo(MemoryInfo&& from) noexcept
1692 : MemoryInfo() {
1693 *this = ::std::move(from);
1694 }
1695
1696 inline MemoryInfo& operator=(const MemoryInfo& from) {
1697 CopyFrom(from);
1698 return *this;
1699 }
1700 inline MemoryInfo& operator=(MemoryInfo&& from) noexcept {
1701 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1702 if (this != &from) InternalSwap(&from);
1703 } else {
1704 CopyFrom(from);
1705 }
1706 return *this;
1707 }
1708
1709 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1710 return GetArenaNoVirtual();
1711 }
1712 inline void* GetMaybeArenaPointer() const final {
1713 return MaybeArenaPtr();
1714 }
1715 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1716 return GetDescriptor();
1717 }
1718 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1719 return GetMetadataStatic().descriptor;
1720 }
1721 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1722 return GetMetadataStatic().reflection;
1723 }
1724 static const MemoryInfo& default_instance();
1725
1726 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1727 static inline const MemoryInfo* internal_default_instance() {
1728 return reinterpret_cast<const MemoryInfo*>(
1729 &_MemoryInfo_default_instance_);
1730 }
1731 static constexpr int kIndexInFileMessages =
1732 9;
1733
1734 friend void swap(MemoryInfo& a, MemoryInfo& b) {
1735 a.Swap(&b);
1736 }
1737 inline void Swap(MemoryInfo* other) {
1738 if (other == this) return;
1739 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1740 InternalSwap(other);
1741 } else {
1742 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1743 }
1744 }
1745 void UnsafeArenaSwap(MemoryInfo* other) {
1746 if (other == this) return;
1747 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1748 InternalSwap(other);
1749 }
1750
1751 // implements Message ----------------------------------------------
1752
1753 inline MemoryInfo* New() const final {
1754 return CreateMaybeMessage<MemoryInfo>(nullptr);
1755 }
1756
1757 MemoryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1758 return CreateMaybeMessage<MemoryInfo>(arena);
1759 }
1760 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1761 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1762 void CopyFrom(const MemoryInfo& from);
1763 void MergeFrom(const MemoryInfo& from);
1764 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1765 bool IsInitialized() const final;
1766
1767 size_t ByteSizeLong() const final;
1768 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1769 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1770 #else
1771 bool MergePartialFromCodedStream(
1772 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1773 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1774 void SerializeWithCachedSizes(
1775 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1776 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1777 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1778 int GetCachedSize() const final { return _cached_size_.Get(); }
1779
1780 private:
1781 inline void SharedCtor();
1782 inline void SharedDtor();
1783 void SetCachedSize(int size) const final;
1784 void InternalSwap(MemoryInfo* other);
1785 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1786 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1787 return "tensorflow.MemoryInfo";
1788 }
1789 protected:
1790 explicit MemoryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1791 private:
1792 static void ArenaDtor(void* object);
1793 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1794 private:
1795 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1796 return _internal_metadata_.arena();
1797 }
1798 inline void* MaybeArenaPtr() const {
1799 return _internal_metadata_.raw_arena_ptr();
1800 }
1801 public:
1802
1803 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1804 private:
1805 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1806 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1807 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
1808 }
1809
1810 public:
1811
1812 // nested types ----------------------------------------------------
1813
1814 // accessors -------------------------------------------------------
1815
1816 enum : int {
1817 kTotalFieldNumber = 1,
1818 kAvailableFieldNumber = 2,
1819 };
1820 // int64 total = 1;
1821 void clear_total();
1822 ::PROTOBUF_NAMESPACE_ID::int64 total() const;
1823 void set_total(::PROTOBUF_NAMESPACE_ID::int64 value);
1824
1825 // int64 available = 2;
1826 void clear_available();
1827 ::PROTOBUF_NAMESPACE_ID::int64 available() const;
1828 void set_available(::PROTOBUF_NAMESPACE_ID::int64 value);
1829
1830 // @@protoc_insertion_point(class_scope:tensorflow.MemoryInfo)
1831 private:
1832 class _Internal;
1833
1834 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1835 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1836 typedef void InternalArenaConstructable_;
1837 typedef void DestructorSkippable_;
1838 ::PROTOBUF_NAMESPACE_ID::int64 total_;
1839 ::PROTOBUF_NAMESPACE_ID::int64 available_;
1840 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1841 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
1842};
1843// -------------------------------------------------------------------
1844
1845class GPUInfo :
1846 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GPUInfo) */ {
1847 public:
1848 GPUInfo();
1849 virtual ~GPUInfo();
1850
1851 GPUInfo(const GPUInfo& from);
1852 GPUInfo(GPUInfo&& from) noexcept
1853 : GPUInfo() {
1854 *this = ::std::move(from);
1855 }
1856
1857 inline GPUInfo& operator=(const GPUInfo& from) {
1858 CopyFrom(from);
1859 return *this;
1860 }
1861 inline GPUInfo& operator=(GPUInfo&& from) noexcept {
1862 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1863 if (this != &from) InternalSwap(&from);
1864 } else {
1865 CopyFrom(from);
1866 }
1867 return *this;
1868 }
1869
1870 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1871 return GetArenaNoVirtual();
1872 }
1873 inline void* GetMaybeArenaPointer() const final {
1874 return MaybeArenaPtr();
1875 }
1876 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1877 return GetDescriptor();
1878 }
1879 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1880 return GetMetadataStatic().descriptor;
1881 }
1882 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1883 return GetMetadataStatic().reflection;
1884 }
1885 static const GPUInfo& default_instance();
1886
1887 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1888 static inline const GPUInfo* internal_default_instance() {
1889 return reinterpret_cast<const GPUInfo*>(
1890 &_GPUInfo_default_instance_);
1891 }
1892 static constexpr int kIndexInFileMessages =
1893 10;
1894
1895 friend void swap(GPUInfo& a, GPUInfo& b) {
1896 a.Swap(&b);
1897 }
1898 inline void Swap(GPUInfo* other) {
1899 if (other == this) return;
1900 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1901 InternalSwap(other);
1902 } else {
1903 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1904 }
1905 }
1906 void UnsafeArenaSwap(GPUInfo* other) {
1907 if (other == this) return;
1908 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1909 InternalSwap(other);
1910 }
1911
1912 // implements Message ----------------------------------------------
1913
1914 inline GPUInfo* New() const final {
1915 return CreateMaybeMessage<GPUInfo>(nullptr);
1916 }
1917
1918 GPUInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1919 return CreateMaybeMessage<GPUInfo>(arena);
1920 }
1921 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1922 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1923 void CopyFrom(const GPUInfo& from);
1924 void MergeFrom(const GPUInfo& from);
1925 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1926 bool IsInitialized() const final;
1927
1928 size_t ByteSizeLong() const final;
1929 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1930 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1931 #else
1932 bool MergePartialFromCodedStream(
1933 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1934 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1935 void SerializeWithCachedSizes(
1936 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1937 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1938 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1939 int GetCachedSize() const final { return _cached_size_.Get(); }
1940
1941 private:
1942 inline void SharedCtor();
1943 inline void SharedDtor();
1944 void SetCachedSize(int size) const final;
1945 void InternalSwap(GPUInfo* other);
1946 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1947 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1948 return "tensorflow.GPUInfo";
1949 }
1950 protected:
1951 explicit GPUInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1952 private:
1953 static void ArenaDtor(void* object);
1954 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1955 private:
1956 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1957 return _internal_metadata_.arena();
1958 }
1959 inline void* MaybeArenaPtr() const {
1960 return _internal_metadata_.raw_arena_ptr();
1961 }
1962 public:
1963
1964 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1965 private:
1966 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1967 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
1968 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
1969 }
1970
1971 public:
1972
1973 // nested types ----------------------------------------------------
1974
1975 // accessors -------------------------------------------------------
1976
1977 enum : int {
1978 kModelFieldNumber = 1,
1979 kUuidFieldNumber = 2,
1980 kBusIdFieldNumber = 3,
1981 };
1982 // string model = 1;
1983 void clear_model();
1984 const std::string& model() const;
1985 void set_model(const std::string& value);
1986 void set_model(std::string&& value);
1987 void set_model(const char* value);
1988 void set_model(const char* value, size_t size);
1989 std::string* mutable_model();
1990 std::string* release_model();
1991 void set_allocated_model(std::string* model);
1992 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1993 " string fields are deprecated and will be removed in a"
1994 " future release.")
1995 std::string* unsafe_arena_release_model();
1996 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1997 " string fields are deprecated and will be removed in a"
1998 " future release.")
1999 void unsafe_arena_set_allocated_model(
2000 std::string* model);
2001
2002 // string uuid = 2;
2003 void clear_uuid();
2004 const std::string& uuid() const;
2005 void set_uuid(const std::string& value);
2006 void set_uuid(std::string&& value);
2007 void set_uuid(const char* value);
2008 void set_uuid(const char* value, size_t size);
2009 std::string* mutable_uuid();
2010 std::string* release_uuid();
2011 void set_allocated_uuid(std::string* uuid);
2012 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2013 " string fields are deprecated and will be removed in a"
2014 " future release.")
2015 std::string* unsafe_arena_release_uuid();
2016 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2017 " string fields are deprecated and will be removed in a"
2018 " future release.")
2019 void unsafe_arena_set_allocated_uuid(
2020 std::string* uuid);
2021
2022 // string bus_id = 3;
2023 void clear_bus_id();
2024 const std::string& bus_id() const;
2025 void set_bus_id(const std::string& value);
2026 void set_bus_id(std::string&& value);
2027 void set_bus_id(const char* value);
2028 void set_bus_id(const char* value, size_t size);
2029 std::string* mutable_bus_id();
2030 std::string* release_bus_id();
2031 void set_allocated_bus_id(std::string* bus_id);
2032 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2033 " string fields are deprecated and will be removed in a"
2034 " future release.")
2035 std::string* unsafe_arena_release_bus_id();
2036 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2037 " string fields are deprecated and will be removed in a"
2038 " future release.")
2039 void unsafe_arena_set_allocated_bus_id(
2040 std::string* bus_id);
2041
2042 // @@protoc_insertion_point(class_scope:tensorflow.GPUInfo)
2043 private:
2044 class _Internal;
2045
2046 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2047 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2048 typedef void InternalArenaConstructable_;
2049 typedef void DestructorSkippable_;
2050 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
2051 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_;
2052 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bus_id_;
2053 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2054 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
2055};
2056// -------------------------------------------------------------------
2057
2058class PlatformInfo :
2059 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.PlatformInfo) */ {
2060 public:
2061 PlatformInfo();
2062 virtual ~PlatformInfo();
2063
2064 PlatformInfo(const PlatformInfo& from);
2065 PlatformInfo(PlatformInfo&& from) noexcept
2066 : PlatformInfo() {
2067 *this = ::std::move(from);
2068 }
2069
2070 inline PlatformInfo& operator=(const PlatformInfo& from) {
2071 CopyFrom(from);
2072 return *this;
2073 }
2074 inline PlatformInfo& operator=(PlatformInfo&& from) noexcept {
2075 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2076 if (this != &from) InternalSwap(&from);
2077 } else {
2078 CopyFrom(from);
2079 }
2080 return *this;
2081 }
2082
2083 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2084 return GetArenaNoVirtual();
2085 }
2086 inline void* GetMaybeArenaPointer() const final {
2087 return MaybeArenaPtr();
2088 }
2089 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2090 return GetDescriptor();
2091 }
2092 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2093 return GetMetadataStatic().descriptor;
2094 }
2095 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2096 return GetMetadataStatic().reflection;
2097 }
2098 static const PlatformInfo& default_instance();
2099
2100 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2101 static inline const PlatformInfo* internal_default_instance() {
2102 return reinterpret_cast<const PlatformInfo*>(
2103 &_PlatformInfo_default_instance_);
2104 }
2105 static constexpr int kIndexInFileMessages =
2106 11;
2107
2108 friend void swap(PlatformInfo& a, PlatformInfo& b) {
2109 a.Swap(&b);
2110 }
2111 inline void Swap(PlatformInfo* other) {
2112 if (other == this) return;
2113 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2114 InternalSwap(other);
2115 } else {
2116 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2117 }
2118 }
2119 void UnsafeArenaSwap(PlatformInfo* other) {
2120 if (other == this) return;
2121 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2122 InternalSwap(other);
2123 }
2124
2125 // implements Message ----------------------------------------------
2126
2127 inline PlatformInfo* New() const final {
2128 return CreateMaybeMessage<PlatformInfo>(nullptr);
2129 }
2130
2131 PlatformInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2132 return CreateMaybeMessage<PlatformInfo>(arena);
2133 }
2134 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2135 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2136 void CopyFrom(const PlatformInfo& from);
2137 void MergeFrom(const PlatformInfo& from);
2138 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2139 bool IsInitialized() const final;
2140
2141 size_t ByteSizeLong() const final;
2142 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2143 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2144 #else
2145 bool MergePartialFromCodedStream(
2146 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2147 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2148 void SerializeWithCachedSizes(
2149 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2150 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2151 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2152 int GetCachedSize() const final { return _cached_size_.Get(); }
2153
2154 private:
2155 inline void SharedCtor();
2156 inline void SharedDtor();
2157 void SetCachedSize(int size) const final;
2158 void InternalSwap(PlatformInfo* other);
2159 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2160 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2161 return "tensorflow.PlatformInfo";
2162 }
2163 protected:
2164 explicit PlatformInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2165 private:
2166 static void ArenaDtor(void* object);
2167 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2168 private:
2169 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2170 return _internal_metadata_.arena();
2171 }
2172 inline void* MaybeArenaPtr() const {
2173 return _internal_metadata_.raw_arena_ptr();
2174 }
2175 public:
2176
2177 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2178 private:
2179 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2180 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
2181 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
2182 }
2183
2184 public:
2185
2186 // nested types ----------------------------------------------------
2187
2188 // accessors -------------------------------------------------------
2189
2190 enum : int {
2191 kBitsFieldNumber = 1,
2192 kLinkageFieldNumber = 2,
2193 kMachineFieldNumber = 3,
2194 kReleaseFieldNumber = 4,
2195 kSystemFieldNumber = 5,
2196 kVersionFieldNumber = 6,
2197 };
2198 // string bits = 1;
2199 void clear_bits();
2200 const std::string& bits() const;
2201 void set_bits(const std::string& value);
2202 void set_bits(std::string&& value);
2203 void set_bits(const char* value);
2204 void set_bits(const char* value, size_t size);
2205 std::string* mutable_bits();
2206 std::string* release_bits();
2207 void set_allocated_bits(std::string* bits);
2208 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2209 " string fields are deprecated and will be removed in a"
2210 " future release.")
2211 std::string* unsafe_arena_release_bits();
2212 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2213 " string fields are deprecated and will be removed in a"
2214 " future release.")
2215 void unsafe_arena_set_allocated_bits(
2216 std::string* bits);
2217
2218 // string linkage = 2;
2219 void clear_linkage();
2220 const std::string& linkage() const;
2221 void set_linkage(const std::string& value);
2222 void set_linkage(std::string&& value);
2223 void set_linkage(const char* value);
2224 void set_linkage(const char* value, size_t size);
2225 std::string* mutable_linkage();
2226 std::string* release_linkage();
2227 void set_allocated_linkage(std::string* linkage);
2228 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2229 " string fields are deprecated and will be removed in a"
2230 " future release.")
2231 std::string* unsafe_arena_release_linkage();
2232 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2233 " string fields are deprecated and will be removed in a"
2234 " future release.")
2235 void unsafe_arena_set_allocated_linkage(
2236 std::string* linkage);
2237
2238 // string machine = 3;
2239 void clear_machine();
2240 const std::string& machine() const;
2241 void set_machine(const std::string& value);
2242 void set_machine(std::string&& value);
2243 void set_machine(const char* value);
2244 void set_machine(const char* value, size_t size);
2245 std::string* mutable_machine();
2246 std::string* release_machine();
2247 void set_allocated_machine(std::string* machine);
2248 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2249 " string fields are deprecated and will be removed in a"
2250 " future release.")
2251 std::string* unsafe_arena_release_machine();
2252 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2253 " string fields are deprecated and will be removed in a"
2254 " future release.")
2255 void unsafe_arena_set_allocated_machine(
2256 std::string* machine);
2257
2258 // string release = 4;
2259 void clear_release();
2260 const std::string& release() const;
2261 void set_release(const std::string& value);
2262 void set_release(std::string&& value);
2263 void set_release(const char* value);
2264 void set_release(const char* value, size_t size);
2265 std::string* mutable_release();
2266 std::string* release_release();
2267 void set_allocated_release(std::string* release);
2268 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2269 " string fields are deprecated and will be removed in a"
2270 " future release.")
2271 std::string* unsafe_arena_release_release();
2272 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2273 " string fields are deprecated and will be removed in a"
2274 " future release.")
2275 void unsafe_arena_set_allocated_release(
2276 std::string* release);
2277
2278 // string system = 5;
2279 void clear_system();
2280 const std::string& system() const;
2281 void set_system(const std::string& value);
2282 void set_system(std::string&& value);
2283 void set_system(const char* value);
2284 void set_system(const char* value, size_t size);
2285 std::string* mutable_system();
2286 std::string* release_system();
2287 void set_allocated_system(std::string* system);
2288 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2289 " string fields are deprecated and will be removed in a"
2290 " future release.")
2291 std::string* unsafe_arena_release_system();
2292 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2293 " string fields are deprecated and will be removed in a"
2294 " future release.")
2295 void unsafe_arena_set_allocated_system(
2296 std::string* system);
2297
2298 // string version = 6;
2299 void clear_version();
2300 const std::string& version() const;
2301 void set_version(const std::string& value);
2302 void set_version(std::string&& value);
2303 void set_version(const char* value);
2304 void set_version(const char* value, size_t size);
2305 std::string* mutable_version();
2306 std::string* release_version();
2307 void set_allocated_version(std::string* version);
2308 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2309 " string fields are deprecated and will be removed in a"
2310 " future release.")
2311 std::string* unsafe_arena_release_version();
2312 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2313 " string fields are deprecated and will be removed in a"
2314 " future release.")
2315 void unsafe_arena_set_allocated_version(
2316 std::string* version);
2317
2318 // @@protoc_insertion_point(class_scope:tensorflow.PlatformInfo)
2319 private:
2320 class _Internal;
2321
2322 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2323 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2324 typedef void InternalArenaConstructable_;
2325 typedef void DestructorSkippable_;
2326 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bits_;
2327 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr linkage_;
2328 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_;
2329 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr release_;
2330 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_;
2331 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
2332 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2333 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
2334};
2335// -------------------------------------------------------------------
2336
2337class AvailableDeviceInfo :
2338 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.AvailableDeviceInfo) */ {
2339 public:
2340 AvailableDeviceInfo();
2341 virtual ~AvailableDeviceInfo();
2342
2343 AvailableDeviceInfo(const AvailableDeviceInfo& from);
2344 AvailableDeviceInfo(AvailableDeviceInfo&& from) noexcept
2345 : AvailableDeviceInfo() {
2346 *this = ::std::move(from);
2347 }
2348
2349 inline AvailableDeviceInfo& operator=(const AvailableDeviceInfo& from) {
2350 CopyFrom(from);
2351 return *this;
2352 }
2353 inline AvailableDeviceInfo& operator=(AvailableDeviceInfo&& from) noexcept {
2354 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2355 if (this != &from) InternalSwap(&from);
2356 } else {
2357 CopyFrom(from);
2358 }
2359 return *this;
2360 }
2361
2362 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2363 return GetArenaNoVirtual();
2364 }
2365 inline void* GetMaybeArenaPointer() const final {
2366 return MaybeArenaPtr();
2367 }
2368 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2369 return GetDescriptor();
2370 }
2371 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2372 return GetMetadataStatic().descriptor;
2373 }
2374 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2375 return GetMetadataStatic().reflection;
2376 }
2377 static const AvailableDeviceInfo& default_instance();
2378
2379 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2380 static inline const AvailableDeviceInfo* internal_default_instance() {
2381 return reinterpret_cast<const AvailableDeviceInfo*>(
2382 &_AvailableDeviceInfo_default_instance_);
2383 }
2384 static constexpr int kIndexInFileMessages =
2385 12;
2386
2387 friend void swap(AvailableDeviceInfo& a, AvailableDeviceInfo& b) {
2388 a.Swap(&b);
2389 }
2390 inline void Swap(AvailableDeviceInfo* other) {
2391 if (other == this) return;
2392 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2393 InternalSwap(other);
2394 } else {
2395 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2396 }
2397 }
2398 void UnsafeArenaSwap(AvailableDeviceInfo* other) {
2399 if (other == this) return;
2400 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2401 InternalSwap(other);
2402 }
2403
2404 // implements Message ----------------------------------------------
2405
2406 inline AvailableDeviceInfo* New() const final {
2407 return CreateMaybeMessage<AvailableDeviceInfo>(nullptr);
2408 }
2409
2410 AvailableDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2411 return CreateMaybeMessage<AvailableDeviceInfo>(arena);
2412 }
2413 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2414 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2415 void CopyFrom(const AvailableDeviceInfo& from);
2416 void MergeFrom(const AvailableDeviceInfo& from);
2417 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2418 bool IsInitialized() const final;
2419
2420 size_t ByteSizeLong() const final;
2421 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2422 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2423 #else
2424 bool MergePartialFromCodedStream(
2425 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2426 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2427 void SerializeWithCachedSizes(
2428 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2429 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2430 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2431 int GetCachedSize() const final { return _cached_size_.Get(); }
2432
2433 private:
2434 inline void SharedCtor();
2435 inline void SharedDtor();
2436 void SetCachedSize(int size) const final;
2437 void InternalSwap(AvailableDeviceInfo* other);
2438 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2439 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2440 return "tensorflow.AvailableDeviceInfo";
2441 }
2442 protected:
2443 explicit AvailableDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2444 private:
2445 static void ArenaDtor(void* object);
2446 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2447 private:
2448 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2449 return _internal_metadata_.arena();
2450 }
2451 inline void* MaybeArenaPtr() const {
2452 return _internal_metadata_.raw_arena_ptr();
2453 }
2454 public:
2455
2456 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2457 private:
2458 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2459 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
2460 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
2461 }
2462
2463 public:
2464
2465 // nested types ----------------------------------------------------
2466
2467 // accessors -------------------------------------------------------
2468
2469 enum : int {
2470 kNameFieldNumber = 1,
2471 kTypeFieldNumber = 2,
2472 kPhysicalDescriptionFieldNumber = 4,
2473 kMemoryLimitFieldNumber = 3,
2474 };
2475 // string name = 1;
2476 void clear_name();
2477 const std::string& name() const;
2478 void set_name(const std::string& value);
2479 void set_name(std::string&& value);
2480 void set_name(const char* value);
2481 void set_name(const char* value, size_t size);
2482 std::string* mutable_name();
2483 std::string* release_name();
2484 void set_allocated_name(std::string* name);
2485 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2486 " string fields are deprecated and will be removed in a"
2487 " future release.")
2488 std::string* unsafe_arena_release_name();
2489 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2490 " string fields are deprecated and will be removed in a"
2491 " future release.")
2492 void unsafe_arena_set_allocated_name(
2493 std::string* name);
2494
2495 // string type = 2;
2496 void clear_type();
2497 const std::string& type() const;
2498 void set_type(const std::string& value);
2499 void set_type(std::string&& value);
2500 void set_type(const char* value);
2501 void set_type(const char* value, size_t size);
2502 std::string* mutable_type();
2503 std::string* release_type();
2504 void set_allocated_type(std::string* type);
2505 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2506 " string fields are deprecated and will be removed in a"
2507 " future release.")
2508 std::string* unsafe_arena_release_type();
2509 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2510 " string fields are deprecated and will be removed in a"
2511 " future release.")
2512 void unsafe_arena_set_allocated_type(
2513 std::string* type);
2514
2515 // string physical_description = 4;
2516 void clear_physical_description();
2517 const std::string& physical_description() const;
2518 void set_physical_description(const std::string& value);
2519 void set_physical_description(std::string&& value);
2520 void set_physical_description(const char* value);
2521 void set_physical_description(const char* value, size_t size);
2522 std::string* mutable_physical_description();
2523 std::string* release_physical_description();
2524 void set_allocated_physical_description(std::string* physical_description);
2525 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2526 " string fields are deprecated and will be removed in a"
2527 " future release.")
2528 std::string* unsafe_arena_release_physical_description();
2529 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2530 " string fields are deprecated and will be removed in a"
2531 " future release.")
2532 void unsafe_arena_set_allocated_physical_description(
2533 std::string* physical_description);
2534
2535 // int64 memory_limit = 3;
2536 void clear_memory_limit();
2537 ::PROTOBUF_NAMESPACE_ID::int64 memory_limit() const;
2538 void set_memory_limit(::PROTOBUF_NAMESPACE_ID::int64 value);
2539
2540 // @@protoc_insertion_point(class_scope:tensorflow.AvailableDeviceInfo)
2541 private:
2542 class _Internal;
2543
2544 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2545 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2546 typedef void InternalArenaConstructable_;
2547 typedef void DestructorSkippable_;
2548 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2549 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
2550 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physical_description_;
2551 ::PROTOBUF_NAMESPACE_ID::int64 memory_limit_;
2552 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2553 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
2554};
2555// -------------------------------------------------------------------
2556
2557class MachineConfiguration :
2558 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.MachineConfiguration) */ {
2559 public:
2560 MachineConfiguration();
2561 virtual ~MachineConfiguration();
2562
2563 MachineConfiguration(const MachineConfiguration& from);
2564 MachineConfiguration(MachineConfiguration&& from) noexcept
2565 : MachineConfiguration() {
2566 *this = ::std::move(from);
2567 }
2568
2569 inline MachineConfiguration& operator=(const MachineConfiguration& from) {
2570 CopyFrom(from);
2571 return *this;
2572 }
2573 inline MachineConfiguration& operator=(MachineConfiguration&& from) noexcept {
2574 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2575 if (this != &from) InternalSwap(&from);
2576 } else {
2577 CopyFrom(from);
2578 }
2579 return *this;
2580 }
2581
2582 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2583 return GetArenaNoVirtual();
2584 }
2585 inline void* GetMaybeArenaPointer() const final {
2586 return MaybeArenaPtr();
2587 }
2588 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2589 return GetDescriptor();
2590 }
2591 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2592 return GetMetadataStatic().descriptor;
2593 }
2594 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2595 return GetMetadataStatic().reflection;
2596 }
2597 static const MachineConfiguration& default_instance();
2598
2599 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2600 static inline const MachineConfiguration* internal_default_instance() {
2601 return reinterpret_cast<const MachineConfiguration*>(
2602 &_MachineConfiguration_default_instance_);
2603 }
2604 static constexpr int kIndexInFileMessages =
2605 13;
2606
2607 friend void swap(MachineConfiguration& a, MachineConfiguration& b) {
2608 a.Swap(&b);
2609 }
2610 inline void Swap(MachineConfiguration* other) {
2611 if (other == this) return;
2612 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2613 InternalSwap(other);
2614 } else {
2615 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2616 }
2617 }
2618 void UnsafeArenaSwap(MachineConfiguration* other) {
2619 if (other == this) return;
2620 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2621 InternalSwap(other);
2622 }
2623
2624 // implements Message ----------------------------------------------
2625
2626 inline MachineConfiguration* New() const final {
2627 return CreateMaybeMessage<MachineConfiguration>(nullptr);
2628 }
2629
2630 MachineConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2631 return CreateMaybeMessage<MachineConfiguration>(arena);
2632 }
2633 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2634 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2635 void CopyFrom(const MachineConfiguration& from);
2636 void MergeFrom(const MachineConfiguration& from);
2637 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2638 bool IsInitialized() const final;
2639
2640 size_t ByteSizeLong() const final;
2641 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2642 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2643 #else
2644 bool MergePartialFromCodedStream(
2645 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2646 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2647 void SerializeWithCachedSizes(
2648 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2649 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2650 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2651 int GetCachedSize() const final { return _cached_size_.Get(); }
2652
2653 private:
2654 inline void SharedCtor();
2655 inline void SharedDtor();
2656 void SetCachedSize(int size) const final;
2657 void InternalSwap(MachineConfiguration* other);
2658 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2659 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2660 return "tensorflow.MachineConfiguration";
2661 }
2662 protected:
2663 explicit MachineConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2664 private:
2665 static void ArenaDtor(void* object);
2666 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2667 private:
2668 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2669 return _internal_metadata_.arena();
2670 }
2671 inline void* MaybeArenaPtr() const {
2672 return _internal_metadata_.raw_arena_ptr();
2673 }
2674 public:
2675
2676 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2677 private:
2678 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2679 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
2680 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
2681 }
2682
2683 public:
2684
2685 // nested types ----------------------------------------------------
2686
2687 // accessors -------------------------------------------------------
2688
2689 enum : int {
2690 kDeviceInfoFieldNumber = 4,
2691 kAvailableDeviceInfoFieldNumber = 5,
2692 kHostnameFieldNumber = 1,
2693 kSerialIdentifierFieldNumber = 7,
2694 kPlatformInfoFieldNumber = 2,
2695 kCpuInfoFieldNumber = 3,
2696 kMemoryInfoFieldNumber = 6,
2697 };
2698 // repeated .google.protobuf.Any device_info = 4;
2699 int device_info_size() const;
2700 void clear_device_info();
2701 PROTOBUF_NAMESPACE_ID::Any* mutable_device_info(int index);
2702 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Any >*
2703 mutable_device_info();
2704 const PROTOBUF_NAMESPACE_ID::Any& device_info(int index) const;
2705 PROTOBUF_NAMESPACE_ID::Any* add_device_info();
2706 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Any >&
2707 device_info() const;
2708
2709 // repeated .tensorflow.AvailableDeviceInfo available_device_info = 5;
2710 int available_device_info_size() const;
2711 void clear_available_device_info();
2712 ::tensorflow::AvailableDeviceInfo* mutable_available_device_info(int index);
2713 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >*
2714 mutable_available_device_info();
2715 const ::tensorflow::AvailableDeviceInfo& available_device_info(int index) const;
2716 ::tensorflow::AvailableDeviceInfo* add_available_device_info();
2717 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >&
2718 available_device_info() const;
2719
2720 // string hostname = 1;
2721 void clear_hostname();
2722 const std::string& hostname() const;
2723 void set_hostname(const std::string& value);
2724 void set_hostname(std::string&& value);
2725 void set_hostname(const char* value);
2726 void set_hostname(const char* value, size_t size);
2727 std::string* mutable_hostname();
2728 std::string* release_hostname();
2729 void set_allocated_hostname(std::string* hostname);
2730 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2731 " string fields are deprecated and will be removed in a"
2732 " future release.")
2733 std::string* unsafe_arena_release_hostname();
2734 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2735 " string fields are deprecated and will be removed in a"
2736 " future release.")
2737 void unsafe_arena_set_allocated_hostname(
2738 std::string* hostname);
2739
2740 // string serial_identifier = 7;
2741 void clear_serial_identifier();
2742 const std::string& serial_identifier() const;
2743 void set_serial_identifier(const std::string& value);
2744 void set_serial_identifier(std::string&& value);
2745 void set_serial_identifier(const char* value);
2746 void set_serial_identifier(const char* value, size_t size);
2747 std::string* mutable_serial_identifier();
2748 std::string* release_serial_identifier();
2749 void set_allocated_serial_identifier(std::string* serial_identifier);
2750 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2751 " string fields are deprecated and will be removed in a"
2752 " future release.")
2753 std::string* unsafe_arena_release_serial_identifier();
2754 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2755 " string fields are deprecated and will be removed in a"
2756 " future release.")
2757 void unsafe_arena_set_allocated_serial_identifier(
2758 std::string* serial_identifier);
2759
2760 // .tensorflow.PlatformInfo platform_info = 2;
2761 bool has_platform_info() const;
2762 void clear_platform_info();
2763 const ::tensorflow::PlatformInfo& platform_info() const;
2764 ::tensorflow::PlatformInfo* release_platform_info();
2765 ::tensorflow::PlatformInfo* mutable_platform_info();
2766 void set_allocated_platform_info(::tensorflow::PlatformInfo* platform_info);
2767 void unsafe_arena_set_allocated_platform_info(
2768 ::tensorflow::PlatformInfo* platform_info);
2769 ::tensorflow::PlatformInfo* unsafe_arena_release_platform_info();
2770
2771 // .tensorflow.CPUInfo cpu_info = 3;
2772 bool has_cpu_info() const;
2773 void clear_cpu_info();
2774 const ::tensorflow::CPUInfo& cpu_info() const;
2775 ::tensorflow::CPUInfo* release_cpu_info();
2776 ::tensorflow::CPUInfo* mutable_cpu_info();
2777 void set_allocated_cpu_info(::tensorflow::CPUInfo* cpu_info);
2778 void unsafe_arena_set_allocated_cpu_info(
2779 ::tensorflow::CPUInfo* cpu_info);
2780 ::tensorflow::CPUInfo* unsafe_arena_release_cpu_info();
2781
2782 // .tensorflow.MemoryInfo memory_info = 6;
2783 bool has_memory_info() const;
2784 void clear_memory_info();
2785 const ::tensorflow::MemoryInfo& memory_info() const;
2786 ::tensorflow::MemoryInfo* release_memory_info();
2787 ::tensorflow::MemoryInfo* mutable_memory_info();
2788 void set_allocated_memory_info(::tensorflow::MemoryInfo* memory_info);
2789 void unsafe_arena_set_allocated_memory_info(
2790 ::tensorflow::MemoryInfo* memory_info);
2791 ::tensorflow::MemoryInfo* unsafe_arena_release_memory_info();
2792
2793 // @@protoc_insertion_point(class_scope:tensorflow.MachineConfiguration)
2794 private:
2795 class _Internal;
2796
2797 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2798 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2799 typedef void InternalArenaConstructable_;
2800 typedef void DestructorSkippable_;
2801 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Any > device_info_;
2802 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo > available_device_info_;
2803 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hostname_;
2804 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_identifier_;
2805 ::tensorflow::PlatformInfo* platform_info_;
2806 ::tensorflow::CPUInfo* cpu_info_;
2807 ::tensorflow::MemoryInfo* memory_info_;
2808 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2809 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
2810};
2811// -------------------------------------------------------------------
2812
2813class RunConfiguration_EnvVarsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RunConfiguration_EnvVarsEntry_DoNotUse,
2814 std::string, std::string,
2815 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
2816 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
2817 0 > {
2818public:
2819 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<RunConfiguration_EnvVarsEntry_DoNotUse,
2820 std::string, std::string,
2821 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
2822 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
2823 0 > SuperType;
2824 RunConfiguration_EnvVarsEntry_DoNotUse();
2825 RunConfiguration_EnvVarsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2826 void MergeFrom(const RunConfiguration_EnvVarsEntry_DoNotUse& other);
2827 static const RunConfiguration_EnvVarsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const RunConfiguration_EnvVarsEntry_DoNotUse*>(&_RunConfiguration_EnvVarsEntry_DoNotUse_default_instance_); }
2828 static bool ValidateKey(std::string* s) {
2829 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.RunConfiguration.EnvVarsEntry.key");
2830 }
2831 static bool ValidateValue(std::string* s) {
2832 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), s->size(), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "tensorflow.RunConfiguration.EnvVarsEntry.value");
2833 }
2834 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
2835 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2836 private:
2837 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2838 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
2839 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[14];
2840 }
2841
2842 public:
2843};
2844
2845// -------------------------------------------------------------------
2846
2847class RunConfiguration :
2848 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.RunConfiguration) */ {
2849 public:
2850 RunConfiguration();
2851 virtual ~RunConfiguration();
2852
2853 RunConfiguration(const RunConfiguration& from);
2854 RunConfiguration(RunConfiguration&& from) noexcept
2855 : RunConfiguration() {
2856 *this = ::std::move(from);
2857 }
2858
2859 inline RunConfiguration& operator=(const RunConfiguration& from) {
2860 CopyFrom(from);
2861 return *this;
2862 }
2863 inline RunConfiguration& operator=(RunConfiguration&& from) noexcept {
2864 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2865 if (this != &from) InternalSwap(&from);
2866 } else {
2867 CopyFrom(from);
2868 }
2869 return *this;
2870 }
2871
2872 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2873 return GetArenaNoVirtual();
2874 }
2875 inline void* GetMaybeArenaPointer() const final {
2876 return MaybeArenaPtr();
2877 }
2878 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2879 return GetDescriptor();
2880 }
2881 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2882 return GetMetadataStatic().descriptor;
2883 }
2884 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2885 return GetMetadataStatic().reflection;
2886 }
2887 static const RunConfiguration& default_instance();
2888
2889 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2890 static inline const RunConfiguration* internal_default_instance() {
2891 return reinterpret_cast<const RunConfiguration*>(
2892 &_RunConfiguration_default_instance_);
2893 }
2894 static constexpr int kIndexInFileMessages =
2895 15;
2896
2897 friend void swap(RunConfiguration& a, RunConfiguration& b) {
2898 a.Swap(&b);
2899 }
2900 inline void Swap(RunConfiguration* other) {
2901 if (other == this) return;
2902 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2903 InternalSwap(other);
2904 } else {
2905 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2906 }
2907 }
2908 void UnsafeArenaSwap(RunConfiguration* other) {
2909 if (other == this) return;
2910 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2911 InternalSwap(other);
2912 }
2913
2914 // implements Message ----------------------------------------------
2915
2916 inline RunConfiguration* New() const final {
2917 return CreateMaybeMessage<RunConfiguration>(nullptr);
2918 }
2919
2920 RunConfiguration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2921 return CreateMaybeMessage<RunConfiguration>(arena);
2922 }
2923 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2924 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2925 void CopyFrom(const RunConfiguration& from);
2926 void MergeFrom(const RunConfiguration& from);
2927 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2928 bool IsInitialized() const final;
2929
2930 size_t ByteSizeLong() const final;
2931 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2932 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2933 #else
2934 bool MergePartialFromCodedStream(
2935 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2936 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2937 void SerializeWithCachedSizes(
2938 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2939 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2940 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2941 int GetCachedSize() const final { return _cached_size_.Get(); }
2942
2943 private:
2944 inline void SharedCtor();
2945 inline void SharedDtor();
2946 void SetCachedSize(int size) const final;
2947 void InternalSwap(RunConfiguration* other);
2948 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2949 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2950 return "tensorflow.RunConfiguration";
2951 }
2952 protected:
2953 explicit RunConfiguration(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2954 private:
2955 static void ArenaDtor(void* object);
2956 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2957 private:
2958 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2959 return _internal_metadata_.arena();
2960 }
2961 inline void* MaybeArenaPtr() const {
2962 return _internal_metadata_.raw_arena_ptr();
2963 }
2964 public:
2965
2966 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2967 private:
2968 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2969 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
2970 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
2971 }
2972
2973 public:
2974
2975 // nested types ----------------------------------------------------
2976
2977
2978 // accessors -------------------------------------------------------
2979
2980 enum : int {
2981 kArgumentFieldNumber = 1,
2982 kEnvVarsFieldNumber = 2,
2983 };
2984 // repeated string argument = 1;
2985 int argument_size() const;
2986 void clear_argument();
2987 const std::string& argument(int index) const;
2988 std::string* mutable_argument(int index);
2989 void set_argument(int index, const std::string& value);
2990 void set_argument(int index, std::string&& value);
2991 void set_argument(int index, const char* value);
2992 void set_argument(int index, const char* value, size_t size);
2993 std::string* add_argument();
2994 void add_argument(const std::string& value);
2995 void add_argument(std::string&& value);
2996 void add_argument(const char* value);
2997 void add_argument(const char* value, size_t size);
2998 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& argument() const;
2999 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_argument();
3000
3001 // map<string, string> env_vars = 2;
3002 int env_vars_size() const;
3003 void clear_env_vars();
3004 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
3005 env_vars() const;
3006 ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
3007 mutable_env_vars();
3008
3009 // @@protoc_insertion_point(class_scope:tensorflow.RunConfiguration)
3010 private:
3011 class _Internal;
3012
3013 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3014 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3015 typedef void InternalArenaConstructable_;
3016 typedef void DestructorSkippable_;
3017 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> argument_;
3018 ::PROTOBUF_NAMESPACE_ID::internal::MapField<
3019 RunConfiguration_EnvVarsEntry_DoNotUse,
3020 std::string, std::string,
3021 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
3022 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
3023 0 > env_vars_;
3024 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3025 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
3026};
3027// -------------------------------------------------------------------
3028
3029class TestResults :
3030 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TestResults) */ {
3031 public:
3032 TestResults();
3033 virtual ~TestResults();
3034
3035 TestResults(const TestResults& from);
3036 TestResults(TestResults&& from) noexcept
3037 : TestResults() {
3038 *this = ::std::move(from);
3039 }
3040
3041 inline TestResults& operator=(const TestResults& from) {
3042 CopyFrom(from);
3043 return *this;
3044 }
3045 inline TestResults& operator=(TestResults&& from) noexcept {
3046 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3047 if (this != &from) InternalSwap(&from);
3048 } else {
3049 CopyFrom(from);
3050 }
3051 return *this;
3052 }
3053
3054 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
3055 return GetArenaNoVirtual();
3056 }
3057 inline void* GetMaybeArenaPointer() const final {
3058 return MaybeArenaPtr();
3059 }
3060 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3061 return GetDescriptor();
3062 }
3063 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3064 return GetMetadataStatic().descriptor;
3065 }
3066 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3067 return GetMetadataStatic().reflection;
3068 }
3069 static const TestResults& default_instance();
3070
3071 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3072 static inline const TestResults* internal_default_instance() {
3073 return reinterpret_cast<const TestResults*>(
3074 &_TestResults_default_instance_);
3075 }
3076 static constexpr int kIndexInFileMessages =
3077 16;
3078
3079 friend void swap(TestResults& a, TestResults& b) {
3080 a.Swap(&b);
3081 }
3082 inline void Swap(TestResults* other) {
3083 if (other == this) return;
3084 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
3085 InternalSwap(other);
3086 } else {
3087 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3088 }
3089 }
3090 void UnsafeArenaSwap(TestResults* other) {
3091 if (other == this) return;
3092 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
3093 InternalSwap(other);
3094 }
3095
3096 // implements Message ----------------------------------------------
3097
3098 inline TestResults* New() const final {
3099 return CreateMaybeMessage<TestResults>(nullptr);
3100 }
3101
3102 TestResults* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3103 return CreateMaybeMessage<TestResults>(arena);
3104 }
3105 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3106 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3107 void CopyFrom(const TestResults& from);
3108 void MergeFrom(const TestResults& from);
3109 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3110 bool IsInitialized() const final;
3111
3112 size_t ByteSizeLong() const final;
3113 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3114 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3115 #else
3116 bool MergePartialFromCodedStream(
3117 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3118 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3119 void SerializeWithCachedSizes(
3120 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3121 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3122 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3123 int GetCachedSize() const final { return _cached_size_.Get(); }
3124
3125 private:
3126 inline void SharedCtor();
3127 inline void SharedDtor();
3128 void SetCachedSize(int size) const final;
3129 void InternalSwap(TestResults* other);
3130 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3131 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3132 return "tensorflow.TestResults";
3133 }
3134 protected:
3135 explicit TestResults(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3136 private:
3137 static void ArenaDtor(void* object);
3138 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3139 private:
3140 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3141 return _internal_metadata_.arena();
3142 }
3143 inline void* MaybeArenaPtr() const {
3144 return _internal_metadata_.raw_arena_ptr();
3145 }
3146 public:
3147
3148 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3149 private:
3150 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3151 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto);
3152 return ::descriptor_table_tensorflow_2fcore_2futil_2ftest_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
3153 }
3154
3155 public:
3156
3157 // nested types ----------------------------------------------------
3158
3159 typedef TestResults_BenchmarkType BenchmarkType;
3160 static constexpr BenchmarkType UNKNOWN =
3161 TestResults_BenchmarkType_UNKNOWN;
3162 static constexpr BenchmarkType CPP_MICROBENCHMARK =
3163 TestResults_BenchmarkType_CPP_MICROBENCHMARK;
3164 static constexpr BenchmarkType PYTHON_BENCHMARK =
3165 TestResults_BenchmarkType_PYTHON_BENCHMARK;
3166 static constexpr BenchmarkType ANDROID_BENCHMARK =
3167 TestResults_BenchmarkType_ANDROID_BENCHMARK;
3168 static constexpr BenchmarkType EDGE_BENCHMARK =
3169 TestResults_BenchmarkType_EDGE_BENCHMARK;
3170 static constexpr BenchmarkType IOS_BENCHMARK =
3171 TestResults_BenchmarkType_IOS_BENCHMARK;
3172 static inline bool BenchmarkType_IsValid(int value) {
3173 return TestResults_BenchmarkType_IsValid(value);
3174 }
3175 static constexpr BenchmarkType BenchmarkType_MIN =
3176 TestResults_BenchmarkType_BenchmarkType_MIN;
3177 static constexpr BenchmarkType BenchmarkType_MAX =
3178 TestResults_BenchmarkType_BenchmarkType_MAX;
3179 static constexpr int BenchmarkType_ARRAYSIZE =
3180 TestResults_BenchmarkType_BenchmarkType_ARRAYSIZE;
3181 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
3182 BenchmarkType_descriptor() {
3183 return TestResults_BenchmarkType_descriptor();
3184 }
3185 template<typename T>
3186 static inline const std::string& BenchmarkType_Name(T enum_t_value) {
3187 static_assert(::std::is_same<T, BenchmarkType>::value ||
3188 ::std::is_integral<T>::value,
3189 "Incorrect type passed to function BenchmarkType_Name.");
3190 return TestResults_BenchmarkType_Name(enum_t_value);
3191 }
3192 static inline bool BenchmarkType_Parse(const std::string& name,
3193 BenchmarkType* value) {
3194 return TestResults_BenchmarkType_Parse(name, value);
3195 }
3196
3197 // accessors -------------------------------------------------------
3198
3199 enum : int {
3200 kTargetFieldNumber = 1,
3201 kNameFieldNumber = 9,
3202 kRunModeFieldNumber = 11,
3203 kTfVersionFieldNumber = 12,
3204 kEntriesFieldNumber = 2,
3205 kBuildConfigurationFieldNumber = 3,
3206 kCommitIdFieldNumber = 4,
3207 kMachineConfigurationFieldNumber = 7,
3208 kRunConfigurationFieldNumber = 8,
3209 kStartTimeFieldNumber = 5,
3210 kRunTimeFieldNumber = 6,
3211 kBenchmarkTypeFieldNumber = 10,
3212 };
3213 // string target = 1;
3214 void clear_target();
3215 const std::string& target() const;
3216 void set_target(const std::string& value);
3217 void set_target(std::string&& value);
3218 void set_target(const char* value);
3219 void set_target(const char* value, size_t size);
3220 std::string* mutable_target();
3221 std::string* release_target();
3222 void set_allocated_target(std::string* target);
3223 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3224 " string fields are deprecated and will be removed in a"
3225 " future release.")
3226 std::string* unsafe_arena_release_target();
3227 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3228 " string fields are deprecated and will be removed in a"
3229 " future release.")
3230 void unsafe_arena_set_allocated_target(
3231 std::string* target);
3232
3233 // string name = 9;
3234 void clear_name();
3235 const std::string& name() const;
3236 void set_name(const std::string& value);
3237 void set_name(std::string&& value);
3238 void set_name(const char* value);
3239 void set_name(const char* value, size_t size);
3240 std::string* mutable_name();
3241 std::string* release_name();
3242 void set_allocated_name(std::string* name);
3243 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3244 " string fields are deprecated and will be removed in a"
3245 " future release.")
3246 std::string* unsafe_arena_release_name();
3247 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3248 " string fields are deprecated and will be removed in a"
3249 " future release.")
3250 void unsafe_arena_set_allocated_name(
3251 std::string* name);
3252
3253 // string run_mode = 11;
3254 void clear_run_mode();
3255 const std::string& run_mode() const;
3256 void set_run_mode(const std::string& value);
3257 void set_run_mode(std::string&& value);
3258 void set_run_mode(const char* value);
3259 void set_run_mode(const char* value, size_t size);
3260 std::string* mutable_run_mode();
3261 std::string* release_run_mode();
3262 void set_allocated_run_mode(std::string* run_mode);
3263 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3264 " string fields are deprecated and will be removed in a"
3265 " future release.")
3266 std::string* unsafe_arena_release_run_mode();
3267 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3268 " string fields are deprecated and will be removed in a"
3269 " future release.")
3270 void unsafe_arena_set_allocated_run_mode(
3271 std::string* run_mode);
3272
3273 // string tf_version = 12;
3274 void clear_tf_version();
3275 const std::string& tf_version() const;
3276 void set_tf_version(const std::string& value);
3277 void set_tf_version(std::string&& value);
3278 void set_tf_version(const char* value);
3279 void set_tf_version(const char* value, size_t size);
3280 std::string* mutable_tf_version();
3281 std::string* release_tf_version();
3282 void set_allocated_tf_version(std::string* tf_version);
3283 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3284 " string fields are deprecated and will be removed in a"
3285 " future release.")
3286 std::string* unsafe_arena_release_tf_version();
3287 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
3288 " string fields are deprecated and will be removed in a"
3289 " future release.")
3290 void unsafe_arena_set_allocated_tf_version(
3291 std::string* tf_version);
3292
3293 // .tensorflow.BenchmarkEntries entries = 2;
3294 bool has_entries() const;
3295 void clear_entries();
3296 const ::tensorflow::BenchmarkEntries& entries() const;
3297 ::tensorflow::BenchmarkEntries* release_entries();
3298 ::tensorflow::BenchmarkEntries* mutable_entries();
3299 void set_allocated_entries(::tensorflow::BenchmarkEntries* entries);
3300 void unsafe_arena_set_allocated_entries(
3301 ::tensorflow::BenchmarkEntries* entries);
3302 ::tensorflow::BenchmarkEntries* unsafe_arena_release_entries();
3303
3304 // .tensorflow.BuildConfiguration build_configuration = 3;
3305 bool has_build_configuration() const;
3306 void clear_build_configuration();
3307 const ::tensorflow::BuildConfiguration& build_configuration() const;
3308 ::tensorflow::BuildConfiguration* release_build_configuration();
3309 ::tensorflow::BuildConfiguration* mutable_build_configuration();
3310 void set_allocated_build_configuration(::tensorflow::BuildConfiguration* build_configuration);
3311 void unsafe_arena_set_allocated_build_configuration(
3312 ::tensorflow::BuildConfiguration* build_configuration);
3313 ::tensorflow::BuildConfiguration* unsafe_arena_release_build_configuration();
3314
3315 // .tensorflow.CommitId commit_id = 4;
3316 bool has_commit_id() const;
3317 void clear_commit_id();
3318 const ::tensorflow::CommitId& commit_id() const;
3319 ::tensorflow::CommitId* release_commit_id();
3320 ::tensorflow::CommitId* mutable_commit_id();
3321 void set_allocated_commit_id(::tensorflow::CommitId* commit_id);
3322 void unsafe_arena_set_allocated_commit_id(
3323 ::tensorflow::CommitId* commit_id);
3324 ::tensorflow::CommitId* unsafe_arena_release_commit_id();
3325
3326 // .tensorflow.MachineConfiguration machine_configuration = 7;
3327 bool has_machine_configuration() const;
3328 void clear_machine_configuration();
3329 const ::tensorflow::MachineConfiguration& machine_configuration() const;
3330 ::tensorflow::MachineConfiguration* release_machine_configuration();
3331 ::tensorflow::MachineConfiguration* mutable_machine_configuration();
3332 void set_allocated_machine_configuration(::tensorflow::MachineConfiguration* machine_configuration);
3333 void unsafe_arena_set_allocated_machine_configuration(
3334 ::tensorflow::MachineConfiguration* machine_configuration);
3335 ::tensorflow::MachineConfiguration* unsafe_arena_release_machine_configuration();
3336
3337 // .tensorflow.RunConfiguration run_configuration = 8;
3338 bool has_run_configuration() const;
3339 void clear_run_configuration();
3340 const ::tensorflow::RunConfiguration& run_configuration() const;
3341 ::tensorflow::RunConfiguration* release_run_configuration();
3342 ::tensorflow::RunConfiguration* mutable_run_configuration();
3343 void set_allocated_run_configuration(::tensorflow::RunConfiguration* run_configuration);
3344 void unsafe_arena_set_allocated_run_configuration(
3345 ::tensorflow::RunConfiguration* run_configuration);
3346 ::tensorflow::RunConfiguration* unsafe_arena_release_run_configuration();
3347
3348 // int64 start_time = 5;
3349 void clear_start_time();
3350 ::PROTOBUF_NAMESPACE_ID::int64 start_time() const;
3351 void set_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
3352
3353 // double run_time = 6;
3354 void clear_run_time();
3355 double run_time() const;
3356 void set_run_time(double value);
3357
3358 // .tensorflow.TestResults.BenchmarkType benchmark_type = 10;
3359 void clear_benchmark_type();
3360 ::tensorflow::TestResults_BenchmarkType benchmark_type() const;
3361 void set_benchmark_type(::tensorflow::TestResults_BenchmarkType value);
3362
3363 // @@protoc_insertion_point(class_scope:tensorflow.TestResults)
3364 private:
3365 class _Internal;
3366
3367 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3368 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3369 typedef void InternalArenaConstructable_;
3370 typedef void DestructorSkippable_;
3371 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_;
3372 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
3373 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr run_mode_;
3374 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tf_version_;
3375 ::tensorflow::BenchmarkEntries* entries_;
3376 ::tensorflow::BuildConfiguration* build_configuration_;
3377 ::tensorflow::CommitId* commit_id_;
3378 ::tensorflow::MachineConfiguration* machine_configuration_;
3379 ::tensorflow::RunConfiguration* run_configuration_;
3380 ::PROTOBUF_NAMESPACE_ID::int64 start_time_;
3381 double run_time_;
3382 int benchmark_type_;
3383 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3384 friend struct ::TableStruct_tensorflow_2fcore_2futil_2ftest_5flog_2eproto;
3385};
3386// ===================================================================
3387
3388
3389// ===================================================================
3390
3391#ifdef __GNUC__
3392 #pragma GCC diagnostic push
3393 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3394#endif // __GNUC__
3395// EntryValue
3396
3397// double double_value = 1;
3398inline bool EntryValue::has_double_value() const {
3399 return kind_case() == kDoubleValue;
3400}
3401inline void EntryValue::set_has_double_value() {
3402 _oneof_case_[0] = kDoubleValue;
3403}
3404inline void EntryValue::clear_double_value() {
3405 if (has_double_value()) {
3406 kind_.double_value_ = 0;
3407 clear_has_kind();
3408 }
3409}
3410inline double EntryValue::double_value() const {
3411 // @@protoc_insertion_point(field_get:tensorflow.EntryValue.double_value)
3412 if (has_double_value()) {
3413 return kind_.double_value_;
3414 }
3415 return 0;
3416}
3417inline void EntryValue::set_double_value(double value) {
3418 if (!has_double_value()) {
3419 clear_kind();
3420 set_has_double_value();
3421 }
3422 kind_.double_value_ = value;
3423 // @@protoc_insertion_point(field_set:tensorflow.EntryValue.double_value)
3424}
3425
3426// string string_value = 2;
3427inline bool EntryValue::has_string_value() const {
3428 return kind_case() == kStringValue;
3429}
3430inline void EntryValue::set_has_string_value() {
3431 _oneof_case_[0] = kStringValue;
3432}
3433inline void EntryValue::clear_string_value() {
3434 if (has_string_value()) {
3435 kind_.string_value_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3436 GetArenaNoVirtual());
3437 clear_has_kind();
3438 }
3439}
3440inline const std::string& EntryValue::string_value() const {
3441 // @@protoc_insertion_point(field_get:tensorflow.EntryValue.string_value)
3442 if (has_string_value()) {
3443 return kind_.string_value_.Get();
3444 }
3445 return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3446}
3447inline void EntryValue::set_string_value(const std::string& value) {
3448 if (!has_string_value()) {
3449 clear_kind();
3450 set_has_string_value();
3451 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3452 }
3453 kind_.string_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
3454 GetArenaNoVirtual());
3455 // @@protoc_insertion_point(field_set:tensorflow.EntryValue.string_value)
3456}
3457inline void EntryValue::set_string_value(std::string&& value) {
3458 // @@protoc_insertion_point(field_set:tensorflow.EntryValue.string_value)
3459 if (!has_string_value()) {
3460 clear_kind();
3461 set_has_string_value();
3462 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3463 }
3464 kind_.string_value_.Set(
3465 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3466 // @@protoc_insertion_point(field_set_rvalue:tensorflow.EntryValue.string_value)
3467}
3468inline void EntryValue::set_string_value(const char* value) {
3469 GOOGLE_DCHECK(value != nullptr);
3470 if (!has_string_value()) {
3471 clear_kind();
3472 set_has_string_value();
3473 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3474 }
3475 kind_.string_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3476 ::std::string(value), GetArenaNoVirtual());
3477 // @@protoc_insertion_point(field_set_char:tensorflow.EntryValue.string_value)
3478}
3479inline void EntryValue::set_string_value(const char* value,
3480 size_t size) {
3481 if (!has_string_value()) {
3482 clear_kind();
3483 set_has_string_value();
3484 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3485 }
3486 kind_.string_value_.Set(
3487 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3488 reinterpret_cast<const char*>(value), size),
3489 GetArenaNoVirtual());
3490 // @@protoc_insertion_point(field_set_pointer:tensorflow.EntryValue.string_value)
3491}
3492inline std::string* EntryValue::mutable_string_value() {
3493 if (!has_string_value()) {
3494 clear_kind();
3495 set_has_string_value();
3496 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3497 }
3498 return kind_.string_value_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3499 GetArenaNoVirtual());
3500 // @@protoc_insertion_point(field_mutable:tensorflow.EntryValue.string_value)
3501}
3502inline std::string* EntryValue::release_string_value() {
3503 // @@protoc_insertion_point(field_release:tensorflow.EntryValue.string_value)
3504 if (has_string_value()) {
3505 clear_has_kind();
3506 return kind_.string_value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3507 GetArenaNoVirtual());
3508 } else {
3509 return nullptr;
3510 }
3511}
3512inline void EntryValue::set_allocated_string_value(std::string* string_value) {
3513 if (has_kind()) {
3514 clear_kind();
3515 }
3516 if (string_value != nullptr) {
3517 set_has_string_value();
3518 kind_.string_value_.UnsafeSetDefault(string_value);
3519 }
3520 // @@protoc_insertion_point(field_set_allocated:tensorflow.EntryValue.string_value)
3521}
3522inline std::string* EntryValue::unsafe_arena_release_string_value() {
3523 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.EntryValue.string_value)
3524 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3525 if (has_string_value()) {
3526 clear_has_kind();
3527 return kind_.string_value_.UnsafeArenaRelease(
3528 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3529 } else {
3530 return nullptr;
3531 }
3532}
3533inline void EntryValue::unsafe_arena_set_allocated_string_value(std::string* string_value) {
3534 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3535 if (!has_string_value()) {
3536 kind_.string_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3537 }
3538 clear_kind();
3539 if (string_value) {
3540 set_has_string_value();
3541 kind_.string_value_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_value, GetArenaNoVirtual());
3542 }
3543 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.EntryValue.string_value)
3544}
3545
3546inline bool EntryValue::has_kind() const {
3547 return kind_case() != KIND_NOT_SET;
3548}
3549inline void EntryValue::clear_has_kind() {
3550 _oneof_case_[0] = KIND_NOT_SET;
3551}
3552inline EntryValue::KindCase EntryValue::kind_case() const {
3553 return EntryValue::KindCase(_oneof_case_[0]);
3554}
3555// -------------------------------------------------------------------
3556
3557// MetricEntry
3558
3559// string name = 1;
3560inline void MetricEntry::clear_name() {
3561 name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3562}
3563inline const std::string& MetricEntry::name() const {
3564 // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.name)
3565 return name_.Get();
3566}
3567inline void MetricEntry::set_name(const std::string& value) {
3568
3569 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3570 // @@protoc_insertion_point(field_set:tensorflow.MetricEntry.name)
3571}
3572inline void MetricEntry::set_name(std::string&& value) {
3573
3574 name_.Set(
3575 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3576 // @@protoc_insertion_point(field_set_rvalue:tensorflow.MetricEntry.name)
3577}
3578inline void MetricEntry::set_name(const char* value) {
3579 GOOGLE_DCHECK(value != nullptr);
3580
3581 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3582 GetArenaNoVirtual());
3583 // @@protoc_insertion_point(field_set_char:tensorflow.MetricEntry.name)
3584}
3585inline void MetricEntry::set_name(const char* value,
3586 size_t size) {
3587
3588 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3589 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3590 // @@protoc_insertion_point(field_set_pointer:tensorflow.MetricEntry.name)
3591}
3592inline std::string* MetricEntry::mutable_name() {
3593
3594 // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.name)
3595 return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3596}
3597inline std::string* MetricEntry::release_name() {
3598 // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.name)
3599
3600 return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3601}
3602inline void MetricEntry::set_allocated_name(std::string* name) {
3603 if (name != nullptr) {
3604
3605 } else {
3606
3607 }
3608 name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
3609 GetArenaNoVirtual());
3610 // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.name)
3611}
3612inline std::string* MetricEntry::unsafe_arena_release_name() {
3613 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MetricEntry.name)
3614 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3615
3616 return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3617 GetArenaNoVirtual());
3618}
3619inline void MetricEntry::unsafe_arena_set_allocated_name(
3620 std::string* name) {
3621 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3622 if (name != nullptr) {
3623
3624 } else {
3625
3626 }
3627 name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3628 name, GetArenaNoVirtual());
3629 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MetricEntry.name)
3630}
3631
3632// double value = 2;
3633inline void MetricEntry::clear_value() {
3634 value_ = 0;
3635}
3636inline double MetricEntry::value() const {
3637 // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.value)
3638 return value_;
3639}
3640inline void MetricEntry::set_value(double value) {
3641
3642 value_ = value;
3643 // @@protoc_insertion_point(field_set:tensorflow.MetricEntry.value)
3644}
3645
3646// .google.protobuf.DoubleValue min_value = 3;
3647inline bool MetricEntry::has_min_value() const {
3648 return this != internal_default_instance() && min_value_ != nullptr;
3649}
3650inline const PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::min_value() const {
3651 const PROTOBUF_NAMESPACE_ID::DoubleValue* p = min_value_;
3652 // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.min_value)
3653 return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::DoubleValue*>(
3654 &PROTOBUF_NAMESPACE_ID::_DoubleValue_default_instance_);
3655}
3656inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::release_min_value() {
3657 // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.min_value)
3658
3659 PROTOBUF_NAMESPACE_ID::DoubleValue* temp = min_value_;
3660 if (GetArenaNoVirtual() != nullptr) {
3661 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3662 }
3663 min_value_ = nullptr;
3664 return temp;
3665}
3666inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::unsafe_arena_release_min_value() {
3667 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MetricEntry.min_value)
3668
3669 PROTOBUF_NAMESPACE_ID::DoubleValue* temp = min_value_;
3670 min_value_ = nullptr;
3671 return temp;
3672}
3673inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::mutable_min_value() {
3674
3675 if (min_value_ == nullptr) {
3676 auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::DoubleValue>(GetArenaNoVirtual());
3677 min_value_ = p;
3678 }
3679 // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.min_value)
3680 return min_value_;
3681}
3682inline void MetricEntry::set_allocated_min_value(PROTOBUF_NAMESPACE_ID::DoubleValue* min_value) {
3683 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3684 if (message_arena == nullptr) {
3685 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_value_);
3686 }
3687 if (min_value) {
3688 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3689 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_value)->GetArena();
3690 if (message_arena != submessage_arena) {
3691 min_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3692 message_arena, min_value, submessage_arena);
3693 }
3694
3695 } else {
3696
3697 }
3698 min_value_ = min_value;
3699 // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.min_value)
3700}
3701
3702// .google.protobuf.DoubleValue max_value = 4;
3703inline bool MetricEntry::has_max_value() const {
3704 return this != internal_default_instance() && max_value_ != nullptr;
3705}
3706inline const PROTOBUF_NAMESPACE_ID::DoubleValue& MetricEntry::max_value() const {
3707 const PROTOBUF_NAMESPACE_ID::DoubleValue* p = max_value_;
3708 // @@protoc_insertion_point(field_get:tensorflow.MetricEntry.max_value)
3709 return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::DoubleValue*>(
3710 &PROTOBUF_NAMESPACE_ID::_DoubleValue_default_instance_);
3711}
3712inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::release_max_value() {
3713 // @@protoc_insertion_point(field_release:tensorflow.MetricEntry.max_value)
3714
3715 PROTOBUF_NAMESPACE_ID::DoubleValue* temp = max_value_;
3716 if (GetArenaNoVirtual() != nullptr) {
3717 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3718 }
3719 max_value_ = nullptr;
3720 return temp;
3721}
3722inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::unsafe_arena_release_max_value() {
3723 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MetricEntry.max_value)
3724
3725 PROTOBUF_NAMESPACE_ID::DoubleValue* temp = max_value_;
3726 max_value_ = nullptr;
3727 return temp;
3728}
3729inline PROTOBUF_NAMESPACE_ID::DoubleValue* MetricEntry::mutable_max_value() {
3730
3731 if (max_value_ == nullptr) {
3732 auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::DoubleValue>(GetArenaNoVirtual());
3733 max_value_ = p;
3734 }
3735 // @@protoc_insertion_point(field_mutable:tensorflow.MetricEntry.max_value)
3736 return max_value_;
3737}
3738inline void MetricEntry::set_allocated_max_value(PROTOBUF_NAMESPACE_ID::DoubleValue* max_value) {
3739 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3740 if (message_arena == nullptr) {
3741 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(max_value_);
3742 }
3743 if (max_value) {
3744 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3745 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(max_value)->GetArena();
3746 if (message_arena != submessage_arena) {
3747 max_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3748 message_arena, max_value, submessage_arena);
3749 }
3750
3751 } else {
3752
3753 }
3754 max_value_ = max_value;
3755 // @@protoc_insertion_point(field_set_allocated:tensorflow.MetricEntry.max_value)
3756}
3757
3758// -------------------------------------------------------------------
3759
3760// -------------------------------------------------------------------
3761
3762// BenchmarkEntry
3763
3764// string name = 1;
3765inline void BenchmarkEntry::clear_name() {
3766 name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3767}
3768inline const std::string& BenchmarkEntry::name() const {
3769 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.name)
3770 return name_.Get();
3771}
3772inline void BenchmarkEntry::set_name(const std::string& value) {
3773
3774 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3775 // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.name)
3776}
3777inline void BenchmarkEntry::set_name(std::string&& value) {
3778
3779 name_.Set(
3780 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3781 // @@protoc_insertion_point(field_set_rvalue:tensorflow.BenchmarkEntry.name)
3782}
3783inline void BenchmarkEntry::set_name(const char* value) {
3784 GOOGLE_DCHECK(value != nullptr);
3785
3786 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3787 GetArenaNoVirtual());
3788 // @@protoc_insertion_point(field_set_char:tensorflow.BenchmarkEntry.name)
3789}
3790inline void BenchmarkEntry::set_name(const char* value,
3791 size_t size) {
3792
3793 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3794 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3795 // @@protoc_insertion_point(field_set_pointer:tensorflow.BenchmarkEntry.name)
3796}
3797inline std::string* BenchmarkEntry::mutable_name() {
3798
3799 // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntry.name)
3800 return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3801}
3802inline std::string* BenchmarkEntry::release_name() {
3803 // @@protoc_insertion_point(field_release:tensorflow.BenchmarkEntry.name)
3804
3805 return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3806}
3807inline void BenchmarkEntry::set_allocated_name(std::string* name) {
3808 if (name != nullptr) {
3809
3810 } else {
3811
3812 }
3813 name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
3814 GetArenaNoVirtual());
3815 // @@protoc_insertion_point(field_set_allocated:tensorflow.BenchmarkEntry.name)
3816}
3817inline std::string* BenchmarkEntry::unsafe_arena_release_name() {
3818 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.BenchmarkEntry.name)
3819 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3820
3821 return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3822 GetArenaNoVirtual());
3823}
3824inline void BenchmarkEntry::unsafe_arena_set_allocated_name(
3825 std::string* name) {
3826 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3827 if (name != nullptr) {
3828
3829 } else {
3830
3831 }
3832 name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3833 name, GetArenaNoVirtual());
3834 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.BenchmarkEntry.name)
3835}
3836
3837// int64 iters = 2;
3838inline void BenchmarkEntry::clear_iters() {
3839 iters_ = PROTOBUF_LONGLONG(0);
3840}
3841inline ::PROTOBUF_NAMESPACE_ID::int64 BenchmarkEntry::iters() const {
3842 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.iters)
3843 return iters_;
3844}
3845inline void BenchmarkEntry::set_iters(::PROTOBUF_NAMESPACE_ID::int64 value) {
3846
3847 iters_ = value;
3848 // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.iters)
3849}
3850
3851// double cpu_time = 3;
3852inline void BenchmarkEntry::clear_cpu_time() {
3853 cpu_time_ = 0;
3854}
3855inline double BenchmarkEntry::cpu_time() const {
3856 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.cpu_time)
3857 return cpu_time_;
3858}
3859inline void BenchmarkEntry::set_cpu_time(double value) {
3860
3861 cpu_time_ = value;
3862 // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.cpu_time)
3863}
3864
3865// double wall_time = 4;
3866inline void BenchmarkEntry::clear_wall_time() {
3867 wall_time_ = 0;
3868}
3869inline double BenchmarkEntry::wall_time() const {
3870 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.wall_time)
3871 return wall_time_;
3872}
3873inline void BenchmarkEntry::set_wall_time(double value) {
3874
3875 wall_time_ = value;
3876 // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.wall_time)
3877}
3878
3879// double throughput = 5;
3880inline void BenchmarkEntry::clear_throughput() {
3881 throughput_ = 0;
3882}
3883inline double BenchmarkEntry::throughput() const {
3884 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.throughput)
3885 return throughput_;
3886}
3887inline void BenchmarkEntry::set_throughput(double value) {
3888
3889 throughput_ = value;
3890 // @@protoc_insertion_point(field_set:tensorflow.BenchmarkEntry.throughput)
3891}
3892
3893// map<string, .tensorflow.EntryValue> extras = 6;
3894inline int BenchmarkEntry::extras_size() const {
3895 return extras_.size();
3896}
3897inline void BenchmarkEntry::clear_extras() {
3898 extras_.Clear();
3899}
3900inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >&
3901BenchmarkEntry::extras() const {
3902 // @@protoc_insertion_point(field_map:tensorflow.BenchmarkEntry.extras)
3903 return extras_.GetMap();
3904}
3905inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::tensorflow::EntryValue >*
3906BenchmarkEntry::mutable_extras() {
3907 // @@protoc_insertion_point(field_mutable_map:tensorflow.BenchmarkEntry.extras)
3908 return extras_.MutableMap();
3909}
3910
3911// repeated .tensorflow.MetricEntry metrics = 7;
3912inline int BenchmarkEntry::metrics_size() const {
3913 return metrics_.size();
3914}
3915inline void BenchmarkEntry::clear_metrics() {
3916 metrics_.Clear();
3917}
3918inline ::tensorflow::MetricEntry* BenchmarkEntry::mutable_metrics(int index) {
3919 // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntry.metrics)
3920 return metrics_.Mutable(index);
3921}
3922inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >*
3923BenchmarkEntry::mutable_metrics() {
3924 // @@protoc_insertion_point(field_mutable_list:tensorflow.BenchmarkEntry.metrics)
3925 return &metrics_;
3926}
3927inline const ::tensorflow::MetricEntry& BenchmarkEntry::metrics(int index) const {
3928 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntry.metrics)
3929 return metrics_.Get(index);
3930}
3931inline ::tensorflow::MetricEntry* BenchmarkEntry::add_metrics() {
3932 // @@protoc_insertion_point(field_add:tensorflow.BenchmarkEntry.metrics)
3933 return metrics_.Add();
3934}
3935inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::MetricEntry >&
3936BenchmarkEntry::metrics() const {
3937 // @@protoc_insertion_point(field_list:tensorflow.BenchmarkEntry.metrics)
3938 return metrics_;
3939}
3940
3941// -------------------------------------------------------------------
3942
3943// BenchmarkEntries
3944
3945// repeated .tensorflow.BenchmarkEntry entry = 1;
3946inline int BenchmarkEntries::entry_size() const {
3947 return entry_.size();
3948}
3949inline void BenchmarkEntries::clear_entry() {
3950 entry_.Clear();
3951}
3952inline ::tensorflow::BenchmarkEntry* BenchmarkEntries::mutable_entry(int index) {
3953 // @@protoc_insertion_point(field_mutable:tensorflow.BenchmarkEntries.entry)
3954 return entry_.Mutable(index);
3955}
3956inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >*
3957BenchmarkEntries::mutable_entry() {
3958 // @@protoc_insertion_point(field_mutable_list:tensorflow.BenchmarkEntries.entry)
3959 return &entry_;
3960}
3961inline const ::tensorflow::BenchmarkEntry& BenchmarkEntries::entry(int index) const {
3962 // @@protoc_insertion_point(field_get:tensorflow.BenchmarkEntries.entry)
3963 return entry_.Get(index);
3964}
3965inline ::tensorflow::BenchmarkEntry* BenchmarkEntries::add_entry() {
3966 // @@protoc_insertion_point(field_add:tensorflow.BenchmarkEntries.entry)
3967 return entry_.Add();
3968}
3969inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::BenchmarkEntry >&
3970BenchmarkEntries::entry() const {
3971 // @@protoc_insertion_point(field_list:tensorflow.BenchmarkEntries.entry)
3972 return entry_;
3973}
3974
3975// -------------------------------------------------------------------
3976
3977// BuildConfiguration
3978
3979// string mode = 1;
3980inline void BuildConfiguration::clear_mode() {
3981 mode_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3982}
3983inline const std::string& BuildConfiguration::mode() const {
3984 // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.mode)
3985 return mode_.Get();
3986}
3987inline void BuildConfiguration::set_mode(const std::string& value) {
3988
3989 mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3990 // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.mode)
3991}
3992inline void BuildConfiguration::set_mode(std::string&& value) {
3993
3994 mode_.Set(
3995 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3996 // @@protoc_insertion_point(field_set_rvalue:tensorflow.BuildConfiguration.mode)
3997}
3998inline void BuildConfiguration::set_mode(const char* value) {
3999 GOOGLE_DCHECK(value != nullptr);
4000
4001 mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4002 GetArenaNoVirtual());
4003 // @@protoc_insertion_point(field_set_char:tensorflow.BuildConfiguration.mode)
4004}
4005inline void BuildConfiguration::set_mode(const char* value,
4006 size_t size) {
4007
4008 mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4009 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4010 // @@protoc_insertion_point(field_set_pointer:tensorflow.BuildConfiguration.mode)
4011}
4012inline std::string* BuildConfiguration::mutable_mode() {
4013
4014 // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.mode)
4015 return mode_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4016}
4017inline std::string* BuildConfiguration::release_mode() {
4018 // @@protoc_insertion_point(field_release:tensorflow.BuildConfiguration.mode)
4019
4020 return mode_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4021}
4022inline void BuildConfiguration::set_allocated_mode(std::string* mode) {
4023 if (mode != nullptr) {
4024
4025 } else {
4026
4027 }
4028 mode_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mode,
4029 GetArenaNoVirtual());
4030 // @@protoc_insertion_point(field_set_allocated:tensorflow.BuildConfiguration.mode)
4031}
4032inline std::string* BuildConfiguration::unsafe_arena_release_mode() {
4033 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.BuildConfiguration.mode)
4034 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4035
4036 return mode_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4037 GetArenaNoVirtual());
4038}
4039inline void BuildConfiguration::unsafe_arena_set_allocated_mode(
4040 std::string* mode) {
4041 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4042 if (mode != nullptr) {
4043
4044 } else {
4045
4046 }
4047 mode_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4048 mode, GetArenaNoVirtual());
4049 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.BuildConfiguration.mode)
4050}
4051
4052// repeated string cc_flags = 2;
4053inline int BuildConfiguration::cc_flags_size() const {
4054 return cc_flags_.size();
4055}
4056inline void BuildConfiguration::clear_cc_flags() {
4057 cc_flags_.Clear();
4058}
4059inline const std::string& BuildConfiguration::cc_flags(int index) const {
4060 // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.cc_flags)
4061 return cc_flags_.Get(index);
4062}
4063inline std::string* BuildConfiguration::mutable_cc_flags(int index) {
4064 // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.cc_flags)
4065 return cc_flags_.Mutable(index);
4066}
4067inline void BuildConfiguration::set_cc_flags(int index, const std::string& value) {
4068 // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.cc_flags)
4069 cc_flags_.Mutable(index)->assign(value);
4070}
4071inline void BuildConfiguration::set_cc_flags(int index, std::string&& value) {
4072 // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.cc_flags)
4073 cc_flags_.Mutable(index)->assign(std::move(value));
4074}
4075inline void BuildConfiguration::set_cc_flags(int index, const char* value) {
4076 GOOGLE_DCHECK(value != nullptr);
4077 cc_flags_.Mutable(index)->assign(value);
4078 // @@protoc_insertion_point(field_set_char:tensorflow.BuildConfiguration.cc_flags)
4079}
4080inline void BuildConfiguration::set_cc_flags(int index, const char* value, size_t size) {
4081 cc_flags_.Mutable(index)->assign(
4082 reinterpret_cast<const char*>(value), size);
4083 // @@protoc_insertion_point(field_set_pointer:tensorflow.BuildConfiguration.cc_flags)
4084}
4085inline std::string* BuildConfiguration::add_cc_flags() {
4086 // @@protoc_insertion_point(field_add_mutable:tensorflow.BuildConfiguration.cc_flags)
4087 return cc_flags_.Add();
4088}
4089inline void BuildConfiguration::add_cc_flags(const std::string& value) {
4090 cc_flags_.Add()->assign(value);
4091 // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.cc_flags)
4092}
4093inline void BuildConfiguration::add_cc_flags(std::string&& value) {
4094 cc_flags_.Add(std::move(value));
4095 // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.cc_flags)
4096}
4097inline void BuildConfiguration::add_cc_flags(const char* value) {
4098 GOOGLE_DCHECK(value != nullptr);
4099 cc_flags_.Add()->assign(value);
4100 // @@protoc_insertion_point(field_add_char:tensorflow.BuildConfiguration.cc_flags)
4101}
4102inline void BuildConfiguration::add_cc_flags(const char* value, size_t size) {
4103 cc_flags_.Add()->assign(reinterpret_cast<const char*>(value), size);
4104 // @@protoc_insertion_point(field_add_pointer:tensorflow.BuildConfiguration.cc_flags)
4105}
4106inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4107BuildConfiguration::cc_flags() const {
4108 // @@protoc_insertion_point(field_list:tensorflow.BuildConfiguration.cc_flags)
4109 return cc_flags_;
4110}
4111inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4112BuildConfiguration::mutable_cc_flags() {
4113 // @@protoc_insertion_point(field_mutable_list:tensorflow.BuildConfiguration.cc_flags)
4114 return &cc_flags_;
4115}
4116
4117// repeated string opts = 3;
4118inline int BuildConfiguration::opts_size() const {
4119 return opts_.size();
4120}
4121inline void BuildConfiguration::clear_opts() {
4122 opts_.Clear();
4123}
4124inline const std::string& BuildConfiguration::opts(int index) const {
4125 // @@protoc_insertion_point(field_get:tensorflow.BuildConfiguration.opts)
4126 return opts_.Get(index);
4127}
4128inline std::string* BuildConfiguration::mutable_opts(int index) {
4129 // @@protoc_insertion_point(field_mutable:tensorflow.BuildConfiguration.opts)
4130 return opts_.Mutable(index);
4131}
4132inline void BuildConfiguration::set_opts(int index, const std::string& value) {
4133 // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.opts)
4134 opts_.Mutable(index)->assign(value);
4135}
4136inline void BuildConfiguration::set_opts(int index, std::string&& value) {
4137 // @@protoc_insertion_point(field_set:tensorflow.BuildConfiguration.opts)
4138 opts_.Mutable(index)->assign(std::move(value));
4139}
4140inline void BuildConfiguration::set_opts(int index, const char* value) {
4141 GOOGLE_DCHECK(value != nullptr);
4142 opts_.Mutable(index)->assign(value);
4143 // @@protoc_insertion_point(field_set_char:tensorflow.BuildConfiguration.opts)
4144}
4145inline void BuildConfiguration::set_opts(int index, const char* value, size_t size) {
4146 opts_.Mutable(index)->assign(
4147 reinterpret_cast<const char*>(value), size);
4148 // @@protoc_insertion_point(field_set_pointer:tensorflow.BuildConfiguration.opts)
4149}
4150inline std::string* BuildConfiguration::add_opts() {
4151 // @@protoc_insertion_point(field_add_mutable:tensorflow.BuildConfiguration.opts)
4152 return opts_.Add();
4153}
4154inline void BuildConfiguration::add_opts(const std::string& value) {
4155 opts_.Add()->assign(value);
4156 // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.opts)
4157}
4158inline void BuildConfiguration::add_opts(std::string&& value) {
4159 opts_.Add(std::move(value));
4160 // @@protoc_insertion_point(field_add:tensorflow.BuildConfiguration.opts)
4161}
4162inline void BuildConfiguration::add_opts(const char* value) {
4163 GOOGLE_DCHECK(value != nullptr);
4164 opts_.Add()->assign(value);
4165 // @@protoc_insertion_point(field_add_char:tensorflow.BuildConfiguration.opts)
4166}
4167inline void BuildConfiguration::add_opts(const char* value, size_t size) {
4168 opts_.Add()->assign(reinterpret_cast<const char*>(value), size);
4169 // @@protoc_insertion_point(field_add_pointer:tensorflow.BuildConfiguration.opts)
4170}
4171inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4172BuildConfiguration::opts() const {
4173 // @@protoc_insertion_point(field_list:tensorflow.BuildConfiguration.opts)
4174 return opts_;
4175}
4176inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4177BuildConfiguration::mutable_opts() {
4178 // @@protoc_insertion_point(field_mutable_list:tensorflow.BuildConfiguration.opts)
4179 return &opts_;
4180}
4181
4182// -------------------------------------------------------------------
4183
4184// CommitId
4185
4186// int64 changelist = 1;
4187inline bool CommitId::has_changelist() const {
4188 return kind_case() == kChangelist;
4189}
4190inline void CommitId::set_has_changelist() {
4191 _oneof_case_[0] = kChangelist;
4192}
4193inline void CommitId::clear_changelist() {
4194 if (has_changelist()) {
4195 kind_.changelist_ = PROTOBUF_LONGLONG(0);
4196 clear_has_kind();
4197 }
4198}
4199inline ::PROTOBUF_NAMESPACE_ID::int64 CommitId::changelist() const {
4200 // @@protoc_insertion_point(field_get:tensorflow.CommitId.changelist)
4201 if (has_changelist()) {
4202 return kind_.changelist_;
4203 }
4204 return PROTOBUF_LONGLONG(0);
4205}
4206inline void CommitId::set_changelist(::PROTOBUF_NAMESPACE_ID::int64 value) {
4207 if (!has_changelist()) {
4208 clear_kind();
4209 set_has_changelist();
4210 }
4211 kind_.changelist_ = value;
4212 // @@protoc_insertion_point(field_set:tensorflow.CommitId.changelist)
4213}
4214
4215// string hash = 2;
4216inline bool CommitId::has_hash() const {
4217 return kind_case() == kHash;
4218}
4219inline void CommitId::set_has_hash() {
4220 _oneof_case_[0] = kHash;
4221}
4222inline void CommitId::clear_hash() {
4223 if (has_hash()) {
4224 kind_.hash_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4225 GetArenaNoVirtual());
4226 clear_has_kind();
4227 }
4228}
4229inline const std::string& CommitId::hash() const {
4230 // @@protoc_insertion_point(field_get:tensorflow.CommitId.hash)
4231 if (has_hash()) {
4232 return kind_.hash_.Get();
4233 }
4234 return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
4235}
4236inline void CommitId::set_hash(const std::string& value) {
4237 if (!has_hash()) {
4238 clear_kind();
4239 set_has_hash();
4240 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4241 }
4242 kind_.hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
4243 GetArenaNoVirtual());
4244 // @@protoc_insertion_point(field_set:tensorflow.CommitId.hash)
4245}
4246inline void CommitId::set_hash(std::string&& value) {
4247 // @@protoc_insertion_point(field_set:tensorflow.CommitId.hash)
4248 if (!has_hash()) {
4249 clear_kind();
4250 set_has_hash();
4251 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4252 }
4253 kind_.hash_.Set(
4254 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4255 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CommitId.hash)
4256}
4257inline void CommitId::set_hash(const char* value) {
4258 GOOGLE_DCHECK(value != nullptr);
4259 if (!has_hash()) {
4260 clear_kind();
4261 set_has_hash();
4262 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4263 }
4264 kind_.hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4265 ::std::string(value), GetArenaNoVirtual());
4266 // @@protoc_insertion_point(field_set_char:tensorflow.CommitId.hash)
4267}
4268inline void CommitId::set_hash(const char* value,
4269 size_t size) {
4270 if (!has_hash()) {
4271 clear_kind();
4272 set_has_hash();
4273 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4274 }
4275 kind_.hash_.Set(
4276 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4277 reinterpret_cast<const char*>(value), size),
4278 GetArenaNoVirtual());
4279 // @@protoc_insertion_point(field_set_pointer:tensorflow.CommitId.hash)
4280}
4281inline std::string* CommitId::mutable_hash() {
4282 if (!has_hash()) {
4283 clear_kind();
4284 set_has_hash();
4285 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4286 }
4287 return kind_.hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4288 GetArenaNoVirtual());
4289 // @@protoc_insertion_point(field_mutable:tensorflow.CommitId.hash)
4290}
4291inline std::string* CommitId::release_hash() {
4292 // @@protoc_insertion_point(field_release:tensorflow.CommitId.hash)
4293 if (has_hash()) {
4294 clear_has_kind();
4295 return kind_.hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4296 GetArenaNoVirtual());
4297 } else {
4298 return nullptr;
4299 }
4300}
4301inline void CommitId::set_allocated_hash(std::string* hash) {
4302 if (has_kind()) {
4303 clear_kind();
4304 }
4305 if (hash != nullptr) {
4306 set_has_hash();
4307 kind_.hash_.UnsafeSetDefault(hash);
4308 }
4309 // @@protoc_insertion_point(field_set_allocated:tensorflow.CommitId.hash)
4310}
4311inline std::string* CommitId::unsafe_arena_release_hash() {
4312 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CommitId.hash)
4313 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4314 if (has_hash()) {
4315 clear_has_kind();
4316 return kind_.hash_.UnsafeArenaRelease(
4317 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4318 } else {
4319 return nullptr;
4320 }
4321}
4322inline void CommitId::unsafe_arena_set_allocated_hash(std::string* hash) {
4323 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4324 if (!has_hash()) {
4325 kind_.hash_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4326 }
4327 clear_kind();
4328 if (hash) {
4329 set_has_hash();
4330 kind_.hash_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hash, GetArenaNoVirtual());
4331 }
4332 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CommitId.hash)
4333}
4334
4335// string snapshot = 3;
4336inline void CommitId::clear_snapshot() {
4337 snapshot_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4338}
4339inline const std::string& CommitId::snapshot() const {
4340 // @@protoc_insertion_point(field_get:tensorflow.CommitId.snapshot)
4341 return snapshot_.Get();
4342}
4343inline void CommitId::set_snapshot(const std::string& value) {
4344
4345 snapshot_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4346 // @@protoc_insertion_point(field_set:tensorflow.CommitId.snapshot)
4347}
4348inline void CommitId::set_snapshot(std::string&& value) {
4349
4350 snapshot_.Set(
4351 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4352 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CommitId.snapshot)
4353}
4354inline void CommitId::set_snapshot(const char* value) {
4355 GOOGLE_DCHECK(value != nullptr);
4356
4357 snapshot_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4358 GetArenaNoVirtual());
4359 // @@protoc_insertion_point(field_set_char:tensorflow.CommitId.snapshot)
4360}
4361inline void CommitId::set_snapshot(const char* value,
4362 size_t size) {
4363
4364 snapshot_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4365 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4366 // @@protoc_insertion_point(field_set_pointer:tensorflow.CommitId.snapshot)
4367}
4368inline std::string* CommitId::mutable_snapshot() {
4369
4370 // @@protoc_insertion_point(field_mutable:tensorflow.CommitId.snapshot)
4371 return snapshot_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4372}
4373inline std::string* CommitId::release_snapshot() {
4374 // @@protoc_insertion_point(field_release:tensorflow.CommitId.snapshot)
4375
4376 return snapshot_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4377}
4378inline void CommitId::set_allocated_snapshot(std::string* snapshot) {
4379 if (snapshot != nullptr) {
4380
4381 } else {
4382
4383 }
4384 snapshot_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), snapshot,
4385 GetArenaNoVirtual());
4386 // @@protoc_insertion_point(field_set_allocated:tensorflow.CommitId.snapshot)
4387}
4388inline std::string* CommitId::unsafe_arena_release_snapshot() {
4389 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CommitId.snapshot)
4390 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4391
4392 return snapshot_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4393 GetArenaNoVirtual());
4394}
4395inline void CommitId::unsafe_arena_set_allocated_snapshot(
4396 std::string* snapshot) {
4397 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4398 if (snapshot != nullptr) {
4399
4400 } else {
4401
4402 }
4403 snapshot_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4404 snapshot, GetArenaNoVirtual());
4405 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CommitId.snapshot)
4406}
4407
4408// int64 pending_changelist = 4;
4409inline void CommitId::clear_pending_changelist() {
4410 pending_changelist_ = PROTOBUF_LONGLONG(0);
4411}
4412inline ::PROTOBUF_NAMESPACE_ID::int64 CommitId::pending_changelist() const {
4413 // @@protoc_insertion_point(field_get:tensorflow.CommitId.pending_changelist)
4414 return pending_changelist_;
4415}
4416inline void CommitId::set_pending_changelist(::PROTOBUF_NAMESPACE_ID::int64 value) {
4417
4418 pending_changelist_ = value;
4419 // @@protoc_insertion_point(field_set:tensorflow.CommitId.pending_changelist)
4420}
4421
4422inline bool CommitId::has_kind() const {
4423 return kind_case() != KIND_NOT_SET;
4424}
4425inline void CommitId::clear_has_kind() {
4426 _oneof_case_[0] = KIND_NOT_SET;
4427}
4428inline CommitId::KindCase CommitId::kind_case() const {
4429 return CommitId::KindCase(_oneof_case_[0]);
4430}
4431// -------------------------------------------------------------------
4432
4433// -------------------------------------------------------------------
4434
4435// CPUInfo
4436
4437// int64 num_cores = 1;
4438inline void CPUInfo::clear_num_cores() {
4439 num_cores_ = PROTOBUF_LONGLONG(0);
4440}
4441inline ::PROTOBUF_NAMESPACE_ID::int64 CPUInfo::num_cores() const {
4442 // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.num_cores)
4443 return num_cores_;
4444}
4445inline void CPUInfo::set_num_cores(::PROTOBUF_NAMESPACE_ID::int64 value) {
4446
4447 num_cores_ = value;
4448 // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.num_cores)
4449}
4450
4451// int64 num_cores_allowed = 2;
4452inline void CPUInfo::clear_num_cores_allowed() {
4453 num_cores_allowed_ = PROTOBUF_LONGLONG(0);
4454}
4455inline ::PROTOBUF_NAMESPACE_ID::int64 CPUInfo::num_cores_allowed() const {
4456 // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.num_cores_allowed)
4457 return num_cores_allowed_;
4458}
4459inline void CPUInfo::set_num_cores_allowed(::PROTOBUF_NAMESPACE_ID::int64 value) {
4460
4461 num_cores_allowed_ = value;
4462 // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.num_cores_allowed)
4463}
4464
4465// double mhz_per_cpu = 3;
4466inline void CPUInfo::clear_mhz_per_cpu() {
4467 mhz_per_cpu_ = 0;
4468}
4469inline double CPUInfo::mhz_per_cpu() const {
4470 // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.mhz_per_cpu)
4471 return mhz_per_cpu_;
4472}
4473inline void CPUInfo::set_mhz_per_cpu(double value) {
4474
4475 mhz_per_cpu_ = value;
4476 // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.mhz_per_cpu)
4477}
4478
4479// string cpu_info = 4;
4480inline void CPUInfo::clear_cpu_info() {
4481 cpu_info_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4482}
4483inline const std::string& CPUInfo::cpu_info() const {
4484 // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.cpu_info)
4485 return cpu_info_.Get();
4486}
4487inline void CPUInfo::set_cpu_info(const std::string& value) {
4488
4489 cpu_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4490 // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.cpu_info)
4491}
4492inline void CPUInfo::set_cpu_info(std::string&& value) {
4493
4494 cpu_info_.Set(
4495 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4496 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CPUInfo.cpu_info)
4497}
4498inline void CPUInfo::set_cpu_info(const char* value) {
4499 GOOGLE_DCHECK(value != nullptr);
4500
4501 cpu_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4502 GetArenaNoVirtual());
4503 // @@protoc_insertion_point(field_set_char:tensorflow.CPUInfo.cpu_info)
4504}
4505inline void CPUInfo::set_cpu_info(const char* value,
4506 size_t size) {
4507
4508 cpu_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4509 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4510 // @@protoc_insertion_point(field_set_pointer:tensorflow.CPUInfo.cpu_info)
4511}
4512inline std::string* CPUInfo::mutable_cpu_info() {
4513
4514 // @@protoc_insertion_point(field_mutable:tensorflow.CPUInfo.cpu_info)
4515 return cpu_info_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4516}
4517inline std::string* CPUInfo::release_cpu_info() {
4518 // @@protoc_insertion_point(field_release:tensorflow.CPUInfo.cpu_info)
4519
4520 return cpu_info_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4521}
4522inline void CPUInfo::set_allocated_cpu_info(std::string* cpu_info) {
4523 if (cpu_info != nullptr) {
4524
4525 } else {
4526
4527 }
4528 cpu_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cpu_info,
4529 GetArenaNoVirtual());
4530 // @@protoc_insertion_point(field_set_allocated:tensorflow.CPUInfo.cpu_info)
4531}
4532inline std::string* CPUInfo::unsafe_arena_release_cpu_info() {
4533 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CPUInfo.cpu_info)
4534 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4535
4536 return cpu_info_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4537 GetArenaNoVirtual());
4538}
4539inline void CPUInfo::unsafe_arena_set_allocated_cpu_info(
4540 std::string* cpu_info) {
4541 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4542 if (cpu_info != nullptr) {
4543
4544 } else {
4545
4546 }
4547 cpu_info_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4548 cpu_info, GetArenaNoVirtual());
4549 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CPUInfo.cpu_info)
4550}
4551
4552// string cpu_governor = 5;
4553inline void CPUInfo::clear_cpu_governor() {
4554 cpu_governor_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4555}
4556inline const std::string& CPUInfo::cpu_governor() const {
4557 // @@protoc_insertion_point(field_get:tensorflow.CPUInfo.cpu_governor)
4558 return cpu_governor_.Get();
4559}
4560inline void CPUInfo::set_cpu_governor(const std::string& value) {
4561
4562 cpu_governor_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4563 // @@protoc_insertion_point(field_set:tensorflow.CPUInfo.cpu_governor)
4564}
4565inline void CPUInfo::set_cpu_governor(std::string&& value) {
4566
4567 cpu_governor_.Set(
4568 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4569 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CPUInfo.cpu_governor)
4570}
4571inline void CPUInfo::set_cpu_governor(const char* value) {
4572 GOOGLE_DCHECK(value != nullptr);
4573
4574 cpu_governor_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4575 GetArenaNoVirtual());
4576 // @@protoc_insertion_point(field_set_char:tensorflow.CPUInfo.cpu_governor)
4577}
4578inline void CPUInfo::set_cpu_governor(const char* value,
4579 size_t size) {
4580
4581 cpu_governor_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4582 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4583 // @@protoc_insertion_point(field_set_pointer:tensorflow.CPUInfo.cpu_governor)
4584}
4585inline std::string* CPUInfo::mutable_cpu_governor() {
4586
4587 // @@protoc_insertion_point(field_mutable:tensorflow.CPUInfo.cpu_governor)
4588 return cpu_governor_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4589}
4590inline std::string* CPUInfo::release_cpu_governor() {
4591 // @@protoc_insertion_point(field_release:tensorflow.CPUInfo.cpu_governor)
4592
4593 return cpu_governor_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4594}
4595inline void CPUInfo::set_allocated_cpu_governor(std::string* cpu_governor) {
4596 if (cpu_governor != nullptr) {
4597
4598 } else {
4599
4600 }
4601 cpu_governor_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cpu_governor,
4602 GetArenaNoVirtual());
4603 // @@protoc_insertion_point(field_set_allocated:tensorflow.CPUInfo.cpu_governor)
4604}
4605inline std::string* CPUInfo::unsafe_arena_release_cpu_governor() {
4606 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CPUInfo.cpu_governor)
4607 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4608
4609 return cpu_governor_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4610 GetArenaNoVirtual());
4611}
4612inline void CPUInfo::unsafe_arena_set_allocated_cpu_governor(
4613 std::string* cpu_governor) {
4614 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4615 if (cpu_governor != nullptr) {
4616
4617 } else {
4618
4619 }
4620 cpu_governor_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4621 cpu_governor, GetArenaNoVirtual());
4622 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CPUInfo.cpu_governor)
4623}
4624
4625// map<string, int64> cache_size = 6;
4626inline int CPUInfo::cache_size_size() const {
4627 return cache_size_.size();
4628}
4629inline void CPUInfo::clear_cache_size() {
4630 cache_size_.Clear();
4631}
4632inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int64 >&
4633CPUInfo::cache_size() const {
4634 // @@protoc_insertion_point(field_map:tensorflow.CPUInfo.cache_size)
4635 return cache_size_.GetMap();
4636}
4637inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::PROTOBUF_NAMESPACE_ID::int64 >*
4638CPUInfo::mutable_cache_size() {
4639 // @@protoc_insertion_point(field_mutable_map:tensorflow.CPUInfo.cache_size)
4640 return cache_size_.MutableMap();
4641}
4642
4643// -------------------------------------------------------------------
4644
4645// MemoryInfo
4646
4647// int64 total = 1;
4648inline void MemoryInfo::clear_total() {
4649 total_ = PROTOBUF_LONGLONG(0);
4650}
4651inline ::PROTOBUF_NAMESPACE_ID::int64 MemoryInfo::total() const {
4652 // @@protoc_insertion_point(field_get:tensorflow.MemoryInfo.total)
4653 return total_;
4654}
4655inline void MemoryInfo::set_total(::PROTOBUF_NAMESPACE_ID::int64 value) {
4656
4657 total_ = value;
4658 // @@protoc_insertion_point(field_set:tensorflow.MemoryInfo.total)
4659}
4660
4661// int64 available = 2;
4662inline void MemoryInfo::clear_available() {
4663 available_ = PROTOBUF_LONGLONG(0);
4664}
4665inline ::PROTOBUF_NAMESPACE_ID::int64 MemoryInfo::available() const {
4666 // @@protoc_insertion_point(field_get:tensorflow.MemoryInfo.available)
4667 return available_;
4668}
4669inline void MemoryInfo::set_available(::PROTOBUF_NAMESPACE_ID::int64 value) {
4670
4671 available_ = value;
4672 // @@protoc_insertion_point(field_set:tensorflow.MemoryInfo.available)
4673}
4674
4675// -------------------------------------------------------------------
4676
4677// GPUInfo
4678
4679// string model = 1;
4680inline void GPUInfo::clear_model() {
4681 model_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4682}
4683inline const std::string& GPUInfo::model() const {
4684 // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.model)
4685 return model_.Get();
4686}
4687inline void GPUInfo::set_model(const std::string& value) {
4688
4689 model_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4690 // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.model)
4691}
4692inline void GPUInfo::set_model(std::string&& value) {
4693
4694 model_.Set(
4695 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4696 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GPUInfo.model)
4697}
4698inline void GPUInfo::set_model(const char* value) {
4699 GOOGLE_DCHECK(value != nullptr);
4700
4701 model_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4702 GetArenaNoVirtual());
4703 // @@protoc_insertion_point(field_set_char:tensorflow.GPUInfo.model)
4704}
4705inline void GPUInfo::set_model(const char* value,
4706 size_t size) {
4707
4708 model_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4709 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4710 // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUInfo.model)
4711}
4712inline std::string* GPUInfo::mutable_model() {
4713
4714 // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.model)
4715 return model_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4716}
4717inline std::string* GPUInfo::release_model() {
4718 // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.model)
4719
4720 return model_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4721}
4722inline void GPUInfo::set_allocated_model(std::string* model) {
4723 if (model != nullptr) {
4724
4725 } else {
4726
4727 }
4728 model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model,
4729 GetArenaNoVirtual());
4730 // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.model)
4731}
4732inline std::string* GPUInfo::unsafe_arena_release_model() {
4733 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUInfo.model)
4734 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4735
4736 return model_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4737 GetArenaNoVirtual());
4738}
4739inline void GPUInfo::unsafe_arena_set_allocated_model(
4740 std::string* model) {
4741 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4742 if (model != nullptr) {
4743
4744 } else {
4745
4746 }
4747 model_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4748 model, GetArenaNoVirtual());
4749 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUInfo.model)
4750}
4751
4752// string uuid = 2;
4753inline void GPUInfo::clear_uuid() {
4754 uuid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4755}
4756inline const std::string& GPUInfo::uuid() const {
4757 // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.uuid)
4758 return uuid_.Get();
4759}
4760inline void GPUInfo::set_uuid(const std::string& value) {
4761
4762 uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4763 // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.uuid)
4764}
4765inline void GPUInfo::set_uuid(std::string&& value) {
4766
4767 uuid_.Set(
4768 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4769 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GPUInfo.uuid)
4770}
4771inline void GPUInfo::set_uuid(const char* value) {
4772 GOOGLE_DCHECK(value != nullptr);
4773
4774 uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4775 GetArenaNoVirtual());
4776 // @@protoc_insertion_point(field_set_char:tensorflow.GPUInfo.uuid)
4777}
4778inline void GPUInfo::set_uuid(const char* value,
4779 size_t size) {
4780
4781 uuid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4782 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4783 // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUInfo.uuid)
4784}
4785inline std::string* GPUInfo::mutable_uuid() {
4786
4787 // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.uuid)
4788 return uuid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4789}
4790inline std::string* GPUInfo::release_uuid() {
4791 // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.uuid)
4792
4793 return uuid_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4794}
4795inline void GPUInfo::set_allocated_uuid(std::string* uuid) {
4796 if (uuid != nullptr) {
4797
4798 } else {
4799
4800 }
4801 uuid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uuid,
4802 GetArenaNoVirtual());
4803 // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.uuid)
4804}
4805inline std::string* GPUInfo::unsafe_arena_release_uuid() {
4806 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUInfo.uuid)
4807 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4808
4809 return uuid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4810 GetArenaNoVirtual());
4811}
4812inline void GPUInfo::unsafe_arena_set_allocated_uuid(
4813 std::string* uuid) {
4814 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4815 if (uuid != nullptr) {
4816
4817 } else {
4818
4819 }
4820 uuid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4821 uuid, GetArenaNoVirtual());
4822 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUInfo.uuid)
4823}
4824
4825// string bus_id = 3;
4826inline void GPUInfo::clear_bus_id() {
4827 bus_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4828}
4829inline const std::string& GPUInfo::bus_id() const {
4830 // @@protoc_insertion_point(field_get:tensorflow.GPUInfo.bus_id)
4831 return bus_id_.Get();
4832}
4833inline void GPUInfo::set_bus_id(const std::string& value) {
4834
4835 bus_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4836 // @@protoc_insertion_point(field_set:tensorflow.GPUInfo.bus_id)
4837}
4838inline void GPUInfo::set_bus_id(std::string&& value) {
4839
4840 bus_id_.Set(
4841 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4842 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GPUInfo.bus_id)
4843}
4844inline void GPUInfo::set_bus_id(const char* value) {
4845 GOOGLE_DCHECK(value != nullptr);
4846
4847 bus_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4848 GetArenaNoVirtual());
4849 // @@protoc_insertion_point(field_set_char:tensorflow.GPUInfo.bus_id)
4850}
4851inline void GPUInfo::set_bus_id(const char* value,
4852 size_t size) {
4853
4854 bus_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4855 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4856 // @@protoc_insertion_point(field_set_pointer:tensorflow.GPUInfo.bus_id)
4857}
4858inline std::string* GPUInfo::mutable_bus_id() {
4859
4860 // @@protoc_insertion_point(field_mutable:tensorflow.GPUInfo.bus_id)
4861 return bus_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4862}
4863inline std::string* GPUInfo::release_bus_id() {
4864 // @@protoc_insertion_point(field_release:tensorflow.GPUInfo.bus_id)
4865
4866 return bus_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4867}
4868inline void GPUInfo::set_allocated_bus_id(std::string* bus_id) {
4869 if (bus_id != nullptr) {
4870
4871 } else {
4872
4873 }
4874 bus_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bus_id,
4875 GetArenaNoVirtual());
4876 // @@protoc_insertion_point(field_set_allocated:tensorflow.GPUInfo.bus_id)
4877}
4878inline std::string* GPUInfo::unsafe_arena_release_bus_id() {
4879 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GPUInfo.bus_id)
4880 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4881
4882 return bus_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4883 GetArenaNoVirtual());
4884}
4885inline void GPUInfo::unsafe_arena_set_allocated_bus_id(
4886 std::string* bus_id) {
4887 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4888 if (bus_id != nullptr) {
4889
4890 } else {
4891
4892 }
4893 bus_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4894 bus_id, GetArenaNoVirtual());
4895 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GPUInfo.bus_id)
4896}
4897
4898// -------------------------------------------------------------------
4899
4900// PlatformInfo
4901
4902// string bits = 1;
4903inline void PlatformInfo::clear_bits() {
4904 bits_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4905}
4906inline const std::string& PlatformInfo::bits() const {
4907 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.bits)
4908 return bits_.Get();
4909}
4910inline void PlatformInfo::set_bits(const std::string& value) {
4911
4912 bits_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4913 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.bits)
4914}
4915inline void PlatformInfo::set_bits(std::string&& value) {
4916
4917 bits_.Set(
4918 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4919 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.bits)
4920}
4921inline void PlatformInfo::set_bits(const char* value) {
4922 GOOGLE_DCHECK(value != nullptr);
4923
4924 bits_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4925 GetArenaNoVirtual());
4926 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.bits)
4927}
4928inline void PlatformInfo::set_bits(const char* value,
4929 size_t size) {
4930
4931 bits_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4932 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4933 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.bits)
4934}
4935inline std::string* PlatformInfo::mutable_bits() {
4936
4937 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.bits)
4938 return bits_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4939}
4940inline std::string* PlatformInfo::release_bits() {
4941 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.bits)
4942
4943 return bits_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4944}
4945inline void PlatformInfo::set_allocated_bits(std::string* bits) {
4946 if (bits != nullptr) {
4947
4948 } else {
4949
4950 }
4951 bits_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bits,
4952 GetArenaNoVirtual());
4953 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.bits)
4954}
4955inline std::string* PlatformInfo::unsafe_arena_release_bits() {
4956 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.bits)
4957 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4958
4959 return bits_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4960 GetArenaNoVirtual());
4961}
4962inline void PlatformInfo::unsafe_arena_set_allocated_bits(
4963 std::string* bits) {
4964 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4965 if (bits != nullptr) {
4966
4967 } else {
4968
4969 }
4970 bits_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4971 bits, GetArenaNoVirtual());
4972 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.bits)
4973}
4974
4975// string linkage = 2;
4976inline void PlatformInfo::clear_linkage() {
4977 linkage_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4978}
4979inline const std::string& PlatformInfo::linkage() const {
4980 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.linkage)
4981 return linkage_.Get();
4982}
4983inline void PlatformInfo::set_linkage(const std::string& value) {
4984
4985 linkage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4986 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.linkage)
4987}
4988inline void PlatformInfo::set_linkage(std::string&& value) {
4989
4990 linkage_.Set(
4991 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4992 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.linkage)
4993}
4994inline void PlatformInfo::set_linkage(const char* value) {
4995 GOOGLE_DCHECK(value != nullptr);
4996
4997 linkage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4998 GetArenaNoVirtual());
4999 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.linkage)
5000}
5001inline void PlatformInfo::set_linkage(const char* value,
5002 size_t size) {
5003
5004 linkage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5005 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5006 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.linkage)
5007}
5008inline std::string* PlatformInfo::mutable_linkage() {
5009
5010 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.linkage)
5011 return linkage_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5012}
5013inline std::string* PlatformInfo::release_linkage() {
5014 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.linkage)
5015
5016 return linkage_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5017}
5018inline void PlatformInfo::set_allocated_linkage(std::string* linkage) {
5019 if (linkage != nullptr) {
5020
5021 } else {
5022
5023 }
5024 linkage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), linkage,
5025 GetArenaNoVirtual());
5026 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.linkage)
5027}
5028inline std::string* PlatformInfo::unsafe_arena_release_linkage() {
5029 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.linkage)
5030 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5031
5032 return linkage_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5033 GetArenaNoVirtual());
5034}
5035inline void PlatformInfo::unsafe_arena_set_allocated_linkage(
5036 std::string* linkage) {
5037 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5038 if (linkage != nullptr) {
5039
5040 } else {
5041
5042 }
5043 linkage_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5044 linkage, GetArenaNoVirtual());
5045 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.linkage)
5046}
5047
5048// string machine = 3;
5049inline void PlatformInfo::clear_machine() {
5050 machine_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5051}
5052inline const std::string& PlatformInfo::machine() const {
5053 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.machine)
5054 return machine_.Get();
5055}
5056inline void PlatformInfo::set_machine(const std::string& value) {
5057
5058 machine_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5059 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.machine)
5060}
5061inline void PlatformInfo::set_machine(std::string&& value) {
5062
5063 machine_.Set(
5064 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5065 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.machine)
5066}
5067inline void PlatformInfo::set_machine(const char* value) {
5068 GOOGLE_DCHECK(value != nullptr);
5069
5070 machine_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5071 GetArenaNoVirtual());
5072 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.machine)
5073}
5074inline void PlatformInfo::set_machine(const char* value,
5075 size_t size) {
5076
5077 machine_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5078 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5079 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.machine)
5080}
5081inline std::string* PlatformInfo::mutable_machine() {
5082
5083 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.machine)
5084 return machine_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5085}
5086inline std::string* PlatformInfo::release_machine() {
5087 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.machine)
5088
5089 return machine_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5090}
5091inline void PlatformInfo::set_allocated_machine(std::string* machine) {
5092 if (machine != nullptr) {
5093
5094 } else {
5095
5096 }
5097 machine_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machine,
5098 GetArenaNoVirtual());
5099 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.machine)
5100}
5101inline std::string* PlatformInfo::unsafe_arena_release_machine() {
5102 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.machine)
5103 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5104
5105 return machine_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5106 GetArenaNoVirtual());
5107}
5108inline void PlatformInfo::unsafe_arena_set_allocated_machine(
5109 std::string* machine) {
5110 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5111 if (machine != nullptr) {
5112
5113 } else {
5114
5115 }
5116 machine_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5117 machine, GetArenaNoVirtual());
5118 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.machine)
5119}
5120
5121// string release = 4;
5122inline void PlatformInfo::clear_release() {
5123 release_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5124}
5125inline const std::string& PlatformInfo::release() const {
5126 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.release)
5127 return release_.Get();
5128}
5129inline void PlatformInfo::set_release(const std::string& value) {
5130
5131 release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5132 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.release)
5133}
5134inline void PlatformInfo::set_release(std::string&& value) {
5135
5136 release_.Set(
5137 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5138 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.release)
5139}
5140inline void PlatformInfo::set_release(const char* value) {
5141 GOOGLE_DCHECK(value != nullptr);
5142
5143 release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5144 GetArenaNoVirtual());
5145 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.release)
5146}
5147inline void PlatformInfo::set_release(const char* value,
5148 size_t size) {
5149
5150 release_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5151 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5152 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.release)
5153}
5154inline std::string* PlatformInfo::mutable_release() {
5155
5156 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.release)
5157 return release_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5158}
5159inline std::string* PlatformInfo::release_release() {
5160 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.release)
5161
5162 return release_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5163}
5164inline void PlatformInfo::set_allocated_release(std::string* release) {
5165 if (release != nullptr) {
5166
5167 } else {
5168
5169 }
5170 release_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), release,
5171 GetArenaNoVirtual());
5172 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.release)
5173}
5174inline std::string* PlatformInfo::unsafe_arena_release_release() {
5175 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.release)
5176 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5177
5178 return release_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5179 GetArenaNoVirtual());
5180}
5181inline void PlatformInfo::unsafe_arena_set_allocated_release(
5182 std::string* release) {
5183 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5184 if (release != nullptr) {
5185
5186 } else {
5187
5188 }
5189 release_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5190 release, GetArenaNoVirtual());
5191 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.release)
5192}
5193
5194// string system = 5;
5195inline void PlatformInfo::clear_system() {
5196 system_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5197}
5198inline const std::string& PlatformInfo::system() const {
5199 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.system)
5200 return system_.Get();
5201}
5202inline void PlatformInfo::set_system(const std::string& value) {
5203
5204 system_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5205 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.system)
5206}
5207inline void PlatformInfo::set_system(std::string&& value) {
5208
5209 system_.Set(
5210 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5211 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.system)
5212}
5213inline void PlatformInfo::set_system(const char* value) {
5214 GOOGLE_DCHECK(value != nullptr);
5215
5216 system_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5217 GetArenaNoVirtual());
5218 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.system)
5219}
5220inline void PlatformInfo::set_system(const char* value,
5221 size_t size) {
5222
5223 system_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5224 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5225 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.system)
5226}
5227inline std::string* PlatformInfo::mutable_system() {
5228
5229 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.system)
5230 return system_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5231}
5232inline std::string* PlatformInfo::release_system() {
5233 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.system)
5234
5235 return system_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5236}
5237inline void PlatformInfo::set_allocated_system(std::string* system) {
5238 if (system != nullptr) {
5239
5240 } else {
5241
5242 }
5243 system_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), system,
5244 GetArenaNoVirtual());
5245 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.system)
5246}
5247inline std::string* PlatformInfo::unsafe_arena_release_system() {
5248 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.system)
5249 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5250
5251 return system_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5252 GetArenaNoVirtual());
5253}
5254inline void PlatformInfo::unsafe_arena_set_allocated_system(
5255 std::string* system) {
5256 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5257 if (system != nullptr) {
5258
5259 } else {
5260
5261 }
5262 system_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5263 system, GetArenaNoVirtual());
5264 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.system)
5265}
5266
5267// string version = 6;
5268inline void PlatformInfo::clear_version() {
5269 version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5270}
5271inline const std::string& PlatformInfo::version() const {
5272 // @@protoc_insertion_point(field_get:tensorflow.PlatformInfo.version)
5273 return version_.Get();
5274}
5275inline void PlatformInfo::set_version(const std::string& value) {
5276
5277 version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5278 // @@protoc_insertion_point(field_set:tensorflow.PlatformInfo.version)
5279}
5280inline void PlatformInfo::set_version(std::string&& value) {
5281
5282 version_.Set(
5283 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5284 // @@protoc_insertion_point(field_set_rvalue:tensorflow.PlatformInfo.version)
5285}
5286inline void PlatformInfo::set_version(const char* value) {
5287 GOOGLE_DCHECK(value != nullptr);
5288
5289 version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5290 GetArenaNoVirtual());
5291 // @@protoc_insertion_point(field_set_char:tensorflow.PlatformInfo.version)
5292}
5293inline void PlatformInfo::set_version(const char* value,
5294 size_t size) {
5295
5296 version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5297 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5298 // @@protoc_insertion_point(field_set_pointer:tensorflow.PlatformInfo.version)
5299}
5300inline std::string* PlatformInfo::mutable_version() {
5301
5302 // @@protoc_insertion_point(field_mutable:tensorflow.PlatformInfo.version)
5303 return version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5304}
5305inline std::string* PlatformInfo::release_version() {
5306 // @@protoc_insertion_point(field_release:tensorflow.PlatformInfo.version)
5307
5308 return version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5309}
5310inline void PlatformInfo::set_allocated_version(std::string* version) {
5311 if (version != nullptr) {
5312
5313 } else {
5314
5315 }
5316 version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
5317 GetArenaNoVirtual());
5318 // @@protoc_insertion_point(field_set_allocated:tensorflow.PlatformInfo.version)
5319}
5320inline std::string* PlatformInfo::unsafe_arena_release_version() {
5321 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.PlatformInfo.version)
5322 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5323
5324 return version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5325 GetArenaNoVirtual());
5326}
5327inline void PlatformInfo::unsafe_arena_set_allocated_version(
5328 std::string* version) {
5329 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5330 if (version != nullptr) {
5331
5332 } else {
5333
5334 }
5335 version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5336 version, GetArenaNoVirtual());
5337 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.PlatformInfo.version)
5338}
5339
5340// -------------------------------------------------------------------
5341
5342// AvailableDeviceInfo
5343
5344// string name = 1;
5345inline void AvailableDeviceInfo::clear_name() {
5346 name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5347}
5348inline const std::string& AvailableDeviceInfo::name() const {
5349 // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.name)
5350 return name_.Get();
5351}
5352inline void AvailableDeviceInfo::set_name(const std::string& value) {
5353
5354 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5355 // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.name)
5356}
5357inline void AvailableDeviceInfo::set_name(std::string&& value) {
5358
5359 name_.Set(
5360 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5361 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AvailableDeviceInfo.name)
5362}
5363inline void AvailableDeviceInfo::set_name(const char* value) {
5364 GOOGLE_DCHECK(value != nullptr);
5365
5366 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5367 GetArenaNoVirtual());
5368 // @@protoc_insertion_point(field_set_char:tensorflow.AvailableDeviceInfo.name)
5369}
5370inline void AvailableDeviceInfo::set_name(const char* value,
5371 size_t size) {
5372
5373 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5374 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5375 // @@protoc_insertion_point(field_set_pointer:tensorflow.AvailableDeviceInfo.name)
5376}
5377inline std::string* AvailableDeviceInfo::mutable_name() {
5378
5379 // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.name)
5380 return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5381}
5382inline std::string* AvailableDeviceInfo::release_name() {
5383 // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.name)
5384
5385 return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5386}
5387inline void AvailableDeviceInfo::set_allocated_name(std::string* name) {
5388 if (name != nullptr) {
5389
5390 } else {
5391
5392 }
5393 name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
5394 GetArenaNoVirtual());
5395 // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.name)
5396}
5397inline std::string* AvailableDeviceInfo::unsafe_arena_release_name() {
5398 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AvailableDeviceInfo.name)
5399 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5400
5401 return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5402 GetArenaNoVirtual());
5403}
5404inline void AvailableDeviceInfo::unsafe_arena_set_allocated_name(
5405 std::string* name) {
5406 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5407 if (name != nullptr) {
5408
5409 } else {
5410
5411 }
5412 name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5413 name, GetArenaNoVirtual());
5414 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AvailableDeviceInfo.name)
5415}
5416
5417// string type = 2;
5418inline void AvailableDeviceInfo::clear_type() {
5419 type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5420}
5421inline const std::string& AvailableDeviceInfo::type() const {
5422 // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.type)
5423 return type_.Get();
5424}
5425inline void AvailableDeviceInfo::set_type(const std::string& value) {
5426
5427 type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5428 // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.type)
5429}
5430inline void AvailableDeviceInfo::set_type(std::string&& value) {
5431
5432 type_.Set(
5433 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5434 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AvailableDeviceInfo.type)
5435}
5436inline void AvailableDeviceInfo::set_type(const char* value) {
5437 GOOGLE_DCHECK(value != nullptr);
5438
5439 type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5440 GetArenaNoVirtual());
5441 // @@protoc_insertion_point(field_set_char:tensorflow.AvailableDeviceInfo.type)
5442}
5443inline void AvailableDeviceInfo::set_type(const char* value,
5444 size_t size) {
5445
5446 type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5447 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5448 // @@protoc_insertion_point(field_set_pointer:tensorflow.AvailableDeviceInfo.type)
5449}
5450inline std::string* AvailableDeviceInfo::mutable_type() {
5451
5452 // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.type)
5453 return type_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5454}
5455inline std::string* AvailableDeviceInfo::release_type() {
5456 // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.type)
5457
5458 return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5459}
5460inline void AvailableDeviceInfo::set_allocated_type(std::string* type) {
5461 if (type != nullptr) {
5462
5463 } else {
5464
5465 }
5466 type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
5467 GetArenaNoVirtual());
5468 // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.type)
5469}
5470inline std::string* AvailableDeviceInfo::unsafe_arena_release_type() {
5471 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AvailableDeviceInfo.type)
5472 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5473
5474 return type_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5475 GetArenaNoVirtual());
5476}
5477inline void AvailableDeviceInfo::unsafe_arena_set_allocated_type(
5478 std::string* type) {
5479 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5480 if (type != nullptr) {
5481
5482 } else {
5483
5484 }
5485 type_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5486 type, GetArenaNoVirtual());
5487 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AvailableDeviceInfo.type)
5488}
5489
5490// int64 memory_limit = 3;
5491inline void AvailableDeviceInfo::clear_memory_limit() {
5492 memory_limit_ = PROTOBUF_LONGLONG(0);
5493}
5494inline ::PROTOBUF_NAMESPACE_ID::int64 AvailableDeviceInfo::memory_limit() const {
5495 // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.memory_limit)
5496 return memory_limit_;
5497}
5498inline void AvailableDeviceInfo::set_memory_limit(::PROTOBUF_NAMESPACE_ID::int64 value) {
5499
5500 memory_limit_ = value;
5501 // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.memory_limit)
5502}
5503
5504// string physical_description = 4;
5505inline void AvailableDeviceInfo::clear_physical_description() {
5506 physical_description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5507}
5508inline const std::string& AvailableDeviceInfo::physical_description() const {
5509 // @@protoc_insertion_point(field_get:tensorflow.AvailableDeviceInfo.physical_description)
5510 return physical_description_.Get();
5511}
5512inline void AvailableDeviceInfo::set_physical_description(const std::string& value) {
5513
5514 physical_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5515 // @@protoc_insertion_point(field_set:tensorflow.AvailableDeviceInfo.physical_description)
5516}
5517inline void AvailableDeviceInfo::set_physical_description(std::string&& value) {
5518
5519 physical_description_.Set(
5520 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5521 // @@protoc_insertion_point(field_set_rvalue:tensorflow.AvailableDeviceInfo.physical_description)
5522}
5523inline void AvailableDeviceInfo::set_physical_description(const char* value) {
5524 GOOGLE_DCHECK(value != nullptr);
5525
5526 physical_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5527 GetArenaNoVirtual());
5528 // @@protoc_insertion_point(field_set_char:tensorflow.AvailableDeviceInfo.physical_description)
5529}
5530inline void AvailableDeviceInfo::set_physical_description(const char* value,
5531 size_t size) {
5532
5533 physical_description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5534 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5535 // @@protoc_insertion_point(field_set_pointer:tensorflow.AvailableDeviceInfo.physical_description)
5536}
5537inline std::string* AvailableDeviceInfo::mutable_physical_description() {
5538
5539 // @@protoc_insertion_point(field_mutable:tensorflow.AvailableDeviceInfo.physical_description)
5540 return physical_description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5541}
5542inline std::string* AvailableDeviceInfo::release_physical_description() {
5543 // @@protoc_insertion_point(field_release:tensorflow.AvailableDeviceInfo.physical_description)
5544
5545 return physical_description_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5546}
5547inline void AvailableDeviceInfo::set_allocated_physical_description(std::string* physical_description) {
5548 if (physical_description != nullptr) {
5549
5550 } else {
5551
5552 }
5553 physical_description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), physical_description,
5554 GetArenaNoVirtual());
5555 // @@protoc_insertion_point(field_set_allocated:tensorflow.AvailableDeviceInfo.physical_description)
5556}
5557inline std::string* AvailableDeviceInfo::unsafe_arena_release_physical_description() {
5558 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.AvailableDeviceInfo.physical_description)
5559 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5560
5561 return physical_description_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5562 GetArenaNoVirtual());
5563}
5564inline void AvailableDeviceInfo::unsafe_arena_set_allocated_physical_description(
5565 std::string* physical_description) {
5566 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5567 if (physical_description != nullptr) {
5568
5569 } else {
5570
5571 }
5572 physical_description_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5573 physical_description, GetArenaNoVirtual());
5574 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.AvailableDeviceInfo.physical_description)
5575}
5576
5577// -------------------------------------------------------------------
5578
5579// MachineConfiguration
5580
5581// string hostname = 1;
5582inline void MachineConfiguration::clear_hostname() {
5583 hostname_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5584}
5585inline const std::string& MachineConfiguration::hostname() const {
5586 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.hostname)
5587 return hostname_.Get();
5588}
5589inline void MachineConfiguration::set_hostname(const std::string& value) {
5590
5591 hostname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5592 // @@protoc_insertion_point(field_set:tensorflow.MachineConfiguration.hostname)
5593}
5594inline void MachineConfiguration::set_hostname(std::string&& value) {
5595
5596 hostname_.Set(
5597 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5598 // @@protoc_insertion_point(field_set_rvalue:tensorflow.MachineConfiguration.hostname)
5599}
5600inline void MachineConfiguration::set_hostname(const char* value) {
5601 GOOGLE_DCHECK(value != nullptr);
5602
5603 hostname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5604 GetArenaNoVirtual());
5605 // @@protoc_insertion_point(field_set_char:tensorflow.MachineConfiguration.hostname)
5606}
5607inline void MachineConfiguration::set_hostname(const char* value,
5608 size_t size) {
5609
5610 hostname_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5611 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5612 // @@protoc_insertion_point(field_set_pointer:tensorflow.MachineConfiguration.hostname)
5613}
5614inline std::string* MachineConfiguration::mutable_hostname() {
5615
5616 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.hostname)
5617 return hostname_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5618}
5619inline std::string* MachineConfiguration::release_hostname() {
5620 // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.hostname)
5621
5622 return hostname_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5623}
5624inline void MachineConfiguration::set_allocated_hostname(std::string* hostname) {
5625 if (hostname != nullptr) {
5626
5627 } else {
5628
5629 }
5630 hostname_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hostname,
5631 GetArenaNoVirtual());
5632 // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.hostname)
5633}
5634inline std::string* MachineConfiguration::unsafe_arena_release_hostname() {
5635 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MachineConfiguration.hostname)
5636 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5637
5638 return hostname_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5639 GetArenaNoVirtual());
5640}
5641inline void MachineConfiguration::unsafe_arena_set_allocated_hostname(
5642 std::string* hostname) {
5643 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5644 if (hostname != nullptr) {
5645
5646 } else {
5647
5648 }
5649 hostname_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5650 hostname, GetArenaNoVirtual());
5651 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MachineConfiguration.hostname)
5652}
5653
5654// string serial_identifier = 7;
5655inline void MachineConfiguration::clear_serial_identifier() {
5656 serial_identifier_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5657}
5658inline const std::string& MachineConfiguration::serial_identifier() const {
5659 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.serial_identifier)
5660 return serial_identifier_.Get();
5661}
5662inline void MachineConfiguration::set_serial_identifier(const std::string& value) {
5663
5664 serial_identifier_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5665 // @@protoc_insertion_point(field_set:tensorflow.MachineConfiguration.serial_identifier)
5666}
5667inline void MachineConfiguration::set_serial_identifier(std::string&& value) {
5668
5669 serial_identifier_.Set(
5670 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5671 // @@protoc_insertion_point(field_set_rvalue:tensorflow.MachineConfiguration.serial_identifier)
5672}
5673inline void MachineConfiguration::set_serial_identifier(const char* value) {
5674 GOOGLE_DCHECK(value != nullptr);
5675
5676 serial_identifier_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5677 GetArenaNoVirtual());
5678 // @@protoc_insertion_point(field_set_char:tensorflow.MachineConfiguration.serial_identifier)
5679}
5680inline void MachineConfiguration::set_serial_identifier(const char* value,
5681 size_t size) {
5682
5683 serial_identifier_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5684 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5685 // @@protoc_insertion_point(field_set_pointer:tensorflow.MachineConfiguration.serial_identifier)
5686}
5687inline std::string* MachineConfiguration::mutable_serial_identifier() {
5688
5689 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.serial_identifier)
5690 return serial_identifier_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5691}
5692inline std::string* MachineConfiguration::release_serial_identifier() {
5693 // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.serial_identifier)
5694
5695 return serial_identifier_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5696}
5697inline void MachineConfiguration::set_allocated_serial_identifier(std::string* serial_identifier) {
5698 if (serial_identifier != nullptr) {
5699
5700 } else {
5701
5702 }
5703 serial_identifier_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serial_identifier,
5704 GetArenaNoVirtual());
5705 // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.serial_identifier)
5706}
5707inline std::string* MachineConfiguration::unsafe_arena_release_serial_identifier() {
5708 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MachineConfiguration.serial_identifier)
5709 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5710
5711 return serial_identifier_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5712 GetArenaNoVirtual());
5713}
5714inline void MachineConfiguration::unsafe_arena_set_allocated_serial_identifier(
5715 std::string* serial_identifier) {
5716 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5717 if (serial_identifier != nullptr) {
5718
5719 } else {
5720
5721 }
5722 serial_identifier_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5723 serial_identifier, GetArenaNoVirtual());
5724 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.MachineConfiguration.serial_identifier)
5725}
5726
5727// .tensorflow.PlatformInfo platform_info = 2;
5728inline bool MachineConfiguration::has_platform_info() const {
5729 return this != internal_default_instance() && platform_info_ != nullptr;
5730}
5731inline void MachineConfiguration::clear_platform_info() {
5732 if (GetArenaNoVirtual() == nullptr && platform_info_ != nullptr) {
5733 delete platform_info_;
5734 }
5735 platform_info_ = nullptr;
5736}
5737inline const ::tensorflow::PlatformInfo& MachineConfiguration::platform_info() const {
5738 const ::tensorflow::PlatformInfo* p = platform_info_;
5739 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.platform_info)
5740 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::PlatformInfo*>(
5741 &::tensorflow::_PlatformInfo_default_instance_);
5742}
5743inline ::tensorflow::PlatformInfo* MachineConfiguration::release_platform_info() {
5744 // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.platform_info)
5745
5746 ::tensorflow::PlatformInfo* temp = platform_info_;
5747 if (GetArenaNoVirtual() != nullptr) {
5748 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5749 }
5750 platform_info_ = nullptr;
5751 return temp;
5752}
5753inline ::tensorflow::PlatformInfo* MachineConfiguration::unsafe_arena_release_platform_info() {
5754 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MachineConfiguration.platform_info)
5755
5756 ::tensorflow::PlatformInfo* temp = platform_info_;
5757 platform_info_ = nullptr;
5758 return temp;
5759}
5760inline ::tensorflow::PlatformInfo* MachineConfiguration::mutable_platform_info() {
5761
5762 if (platform_info_ == nullptr) {
5763 auto* p = CreateMaybeMessage<::tensorflow::PlatformInfo>(GetArenaNoVirtual());
5764 platform_info_ = p;
5765 }
5766 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.platform_info)
5767 return platform_info_;
5768}
5769inline void MachineConfiguration::set_allocated_platform_info(::tensorflow::PlatformInfo* platform_info) {
5770 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5771 if (message_arena == nullptr) {
5772 delete platform_info_;
5773 }
5774 if (platform_info) {
5775 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5776 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(platform_info);
5777 if (message_arena != submessage_arena) {
5778 platform_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5779 message_arena, platform_info, submessage_arena);
5780 }
5781
5782 } else {
5783
5784 }
5785 platform_info_ = platform_info;
5786 // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.platform_info)
5787}
5788
5789// .tensorflow.CPUInfo cpu_info = 3;
5790inline bool MachineConfiguration::has_cpu_info() const {
5791 return this != internal_default_instance() && cpu_info_ != nullptr;
5792}
5793inline void MachineConfiguration::clear_cpu_info() {
5794 if (GetArenaNoVirtual() == nullptr && cpu_info_ != nullptr) {
5795 delete cpu_info_;
5796 }
5797 cpu_info_ = nullptr;
5798}
5799inline const ::tensorflow::CPUInfo& MachineConfiguration::cpu_info() const {
5800 const ::tensorflow::CPUInfo* p = cpu_info_;
5801 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.cpu_info)
5802 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CPUInfo*>(
5803 &::tensorflow::_CPUInfo_default_instance_);
5804}
5805inline ::tensorflow::CPUInfo* MachineConfiguration::release_cpu_info() {
5806 // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.cpu_info)
5807
5808 ::tensorflow::CPUInfo* temp = cpu_info_;
5809 if (GetArenaNoVirtual() != nullptr) {
5810 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5811 }
5812 cpu_info_ = nullptr;
5813 return temp;
5814}
5815inline ::tensorflow::CPUInfo* MachineConfiguration::unsafe_arena_release_cpu_info() {
5816 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MachineConfiguration.cpu_info)
5817
5818 ::tensorflow::CPUInfo* temp = cpu_info_;
5819 cpu_info_ = nullptr;
5820 return temp;
5821}
5822inline ::tensorflow::CPUInfo* MachineConfiguration::mutable_cpu_info() {
5823
5824 if (cpu_info_ == nullptr) {
5825 auto* p = CreateMaybeMessage<::tensorflow::CPUInfo>(GetArenaNoVirtual());
5826 cpu_info_ = p;
5827 }
5828 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.cpu_info)
5829 return cpu_info_;
5830}
5831inline void MachineConfiguration::set_allocated_cpu_info(::tensorflow::CPUInfo* cpu_info) {
5832 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5833 if (message_arena == nullptr) {
5834 delete cpu_info_;
5835 }
5836 if (cpu_info) {
5837 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5838 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cpu_info);
5839 if (message_arena != submessage_arena) {
5840 cpu_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5841 message_arena, cpu_info, submessage_arena);
5842 }
5843
5844 } else {
5845
5846 }
5847 cpu_info_ = cpu_info;
5848 // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.cpu_info)
5849}
5850
5851// repeated .google.protobuf.Any device_info = 4;
5852inline int MachineConfiguration::device_info_size() const {
5853 return device_info_.size();
5854}
5855inline PROTOBUF_NAMESPACE_ID::Any* MachineConfiguration::mutable_device_info(int index) {
5856 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.device_info)
5857 return device_info_.Mutable(index);
5858}
5859inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Any >*
5860MachineConfiguration::mutable_device_info() {
5861 // @@protoc_insertion_point(field_mutable_list:tensorflow.MachineConfiguration.device_info)
5862 return &device_info_;
5863}
5864inline const PROTOBUF_NAMESPACE_ID::Any& MachineConfiguration::device_info(int index) const {
5865 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.device_info)
5866 return device_info_.Get(index);
5867}
5868inline PROTOBUF_NAMESPACE_ID::Any* MachineConfiguration::add_device_info() {
5869 // @@protoc_insertion_point(field_add:tensorflow.MachineConfiguration.device_info)
5870 return device_info_.Add();
5871}
5872inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< PROTOBUF_NAMESPACE_ID::Any >&
5873MachineConfiguration::device_info() const {
5874 // @@protoc_insertion_point(field_list:tensorflow.MachineConfiguration.device_info)
5875 return device_info_;
5876}
5877
5878// repeated .tensorflow.AvailableDeviceInfo available_device_info = 5;
5879inline int MachineConfiguration::available_device_info_size() const {
5880 return available_device_info_.size();
5881}
5882inline void MachineConfiguration::clear_available_device_info() {
5883 available_device_info_.Clear();
5884}
5885inline ::tensorflow::AvailableDeviceInfo* MachineConfiguration::mutable_available_device_info(int index) {
5886 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.available_device_info)
5887 return available_device_info_.Mutable(index);
5888}
5889inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >*
5890MachineConfiguration::mutable_available_device_info() {
5891 // @@protoc_insertion_point(field_mutable_list:tensorflow.MachineConfiguration.available_device_info)
5892 return &available_device_info_;
5893}
5894inline const ::tensorflow::AvailableDeviceInfo& MachineConfiguration::available_device_info(int index) const {
5895 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.available_device_info)
5896 return available_device_info_.Get(index);
5897}
5898inline ::tensorflow::AvailableDeviceInfo* MachineConfiguration::add_available_device_info() {
5899 // @@protoc_insertion_point(field_add:tensorflow.MachineConfiguration.available_device_info)
5900 return available_device_info_.Add();
5901}
5902inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::AvailableDeviceInfo >&
5903MachineConfiguration::available_device_info() const {
5904 // @@protoc_insertion_point(field_list:tensorflow.MachineConfiguration.available_device_info)
5905 return available_device_info_;
5906}
5907
5908// .tensorflow.MemoryInfo memory_info = 6;
5909inline bool MachineConfiguration::has_memory_info() const {
5910 return this != internal_default_instance() && memory_info_ != nullptr;
5911}
5912inline void MachineConfiguration::clear_memory_info() {
5913 if (GetArenaNoVirtual() == nullptr && memory_info_ != nullptr) {
5914 delete memory_info_;
5915 }
5916 memory_info_ = nullptr;
5917}
5918inline const ::tensorflow::MemoryInfo& MachineConfiguration::memory_info() const {
5919 const ::tensorflow::MemoryInfo* p = memory_info_;
5920 // @@protoc_insertion_point(field_get:tensorflow.MachineConfiguration.memory_info)
5921 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::MemoryInfo*>(
5922 &::tensorflow::_MemoryInfo_default_instance_);
5923}
5924inline ::tensorflow::MemoryInfo* MachineConfiguration::release_memory_info() {
5925 // @@protoc_insertion_point(field_release:tensorflow.MachineConfiguration.memory_info)
5926
5927 ::tensorflow::MemoryInfo* temp = memory_info_;
5928 if (GetArenaNoVirtual() != nullptr) {
5929 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5930 }
5931 memory_info_ = nullptr;
5932 return temp;
5933}
5934inline ::tensorflow::MemoryInfo* MachineConfiguration::unsafe_arena_release_memory_info() {
5935 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.MachineConfiguration.memory_info)
5936
5937 ::tensorflow::MemoryInfo* temp = memory_info_;
5938 memory_info_ = nullptr;
5939 return temp;
5940}
5941inline ::tensorflow::MemoryInfo* MachineConfiguration::mutable_memory_info() {
5942
5943 if (memory_info_ == nullptr) {
5944 auto* p = CreateMaybeMessage<::tensorflow::MemoryInfo>(GetArenaNoVirtual());
5945 memory_info_ = p;
5946 }
5947 // @@protoc_insertion_point(field_mutable:tensorflow.MachineConfiguration.memory_info)
5948 return memory_info_;
5949}
5950inline void MachineConfiguration::set_allocated_memory_info(::tensorflow::MemoryInfo* memory_info) {
5951 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5952 if (message_arena == nullptr) {
5953 delete memory_info_;
5954 }
5955 if (memory_info) {
5956 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5957 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(memory_info);
5958 if (message_arena != submessage_arena) {
5959 memory_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5960 message_arena, memory_info, submessage_arena);
5961 }
5962
5963 } else {
5964
5965 }
5966 memory_info_ = memory_info;
5967 // @@protoc_insertion_point(field_set_allocated:tensorflow.MachineConfiguration.memory_info)
5968}
5969
5970// -------------------------------------------------------------------
5971
5972// -------------------------------------------------------------------
5973
5974// RunConfiguration
5975
5976// repeated string argument = 1;
5977inline int RunConfiguration::argument_size() const {
5978 return argument_.size();
5979}
5980inline void RunConfiguration::clear_argument() {
5981 argument_.Clear();
5982}
5983inline const std::string& RunConfiguration::argument(int index) const {
5984 // @@protoc_insertion_point(field_get:tensorflow.RunConfiguration.argument)
5985 return argument_.Get(index);
5986}
5987inline std::string* RunConfiguration::mutable_argument(int index) {
5988 // @@protoc_insertion_point(field_mutable:tensorflow.RunConfiguration.argument)
5989 return argument_.Mutable(index);
5990}
5991inline void RunConfiguration::set_argument(int index, const std::string& value) {
5992 // @@protoc_insertion_point(field_set:tensorflow.RunConfiguration.argument)
5993 argument_.Mutable(index)->assign(value);
5994}
5995inline void RunConfiguration::set_argument(int index, std::string&& value) {
5996 // @@protoc_insertion_point(field_set:tensorflow.RunConfiguration.argument)
5997 argument_.Mutable(index)->assign(std::move(value));
5998}
5999inline void RunConfiguration::set_argument(int index, const char* value) {
6000 GOOGLE_DCHECK(value != nullptr);
6001 argument_.Mutable(index)->assign(value);
6002 // @@protoc_insertion_point(field_set_char:tensorflow.RunConfiguration.argument)
6003}
6004inline void RunConfiguration::set_argument(int index, const char* value, size_t size) {
6005 argument_.Mutable(index)->assign(
6006 reinterpret_cast<const char*>(value), size);
6007 // @@protoc_insertion_point(field_set_pointer:tensorflow.RunConfiguration.argument)
6008}
6009inline std::string* RunConfiguration::add_argument() {
6010 // @@protoc_insertion_point(field_add_mutable:tensorflow.RunConfiguration.argument)
6011 return argument_.Add();
6012}
6013inline void RunConfiguration::add_argument(const std::string& value) {
6014 argument_.Add()->assign(value);
6015 // @@protoc_insertion_point(field_add:tensorflow.RunConfiguration.argument)
6016}
6017inline void RunConfiguration::add_argument(std::string&& value) {
6018 argument_.Add(std::move(value));
6019 // @@protoc_insertion_point(field_add:tensorflow.RunConfiguration.argument)
6020}
6021inline void RunConfiguration::add_argument(const char* value) {
6022 GOOGLE_DCHECK(value != nullptr);
6023 argument_.Add()->assign(value);
6024 // @@protoc_insertion_point(field_add_char:tensorflow.RunConfiguration.argument)
6025}
6026inline void RunConfiguration::add_argument(const char* value, size_t size) {
6027 argument_.Add()->assign(reinterpret_cast<const char*>(value), size);
6028 // @@protoc_insertion_point(field_add_pointer:tensorflow.RunConfiguration.argument)
6029}
6030inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
6031RunConfiguration::argument() const {
6032 // @@protoc_insertion_point(field_list:tensorflow.RunConfiguration.argument)
6033 return argument_;
6034}
6035inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
6036RunConfiguration::mutable_argument() {
6037 // @@protoc_insertion_point(field_mutable_list:tensorflow.RunConfiguration.argument)
6038 return &argument_;
6039}
6040
6041// map<string, string> env_vars = 2;
6042inline int RunConfiguration::env_vars_size() const {
6043 return env_vars_.size();
6044}
6045inline void RunConfiguration::clear_env_vars() {
6046 env_vars_.Clear();
6047}
6048inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
6049RunConfiguration::env_vars() const {
6050 // @@protoc_insertion_point(field_map:tensorflow.RunConfiguration.env_vars)
6051 return env_vars_.GetMap();
6052}
6053inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
6054RunConfiguration::mutable_env_vars() {
6055 // @@protoc_insertion_point(field_mutable_map:tensorflow.RunConfiguration.env_vars)
6056 return env_vars_.MutableMap();
6057}
6058
6059// -------------------------------------------------------------------
6060
6061// TestResults
6062
6063// string target = 1;
6064inline void TestResults::clear_target() {
6065 target_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6066}
6067inline const std::string& TestResults::target() const {
6068 // @@protoc_insertion_point(field_get:tensorflow.TestResults.target)
6069 return target_.Get();
6070}
6071inline void TestResults::set_target(const std::string& value) {
6072
6073 target_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
6074 // @@protoc_insertion_point(field_set:tensorflow.TestResults.target)
6075}
6076inline void TestResults::set_target(std::string&& value) {
6077
6078 target_.Set(
6079 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
6080 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TestResults.target)
6081}
6082inline void TestResults::set_target(const char* value) {
6083 GOOGLE_DCHECK(value != nullptr);
6084
6085 target_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
6086 GetArenaNoVirtual());
6087 // @@protoc_insertion_point(field_set_char:tensorflow.TestResults.target)
6088}
6089inline void TestResults::set_target(const char* value,
6090 size_t size) {
6091
6092 target_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
6093 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
6094 // @@protoc_insertion_point(field_set_pointer:tensorflow.TestResults.target)
6095}
6096inline std::string* TestResults::mutable_target() {
6097
6098 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.target)
6099 return target_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6100}
6101inline std::string* TestResults::release_target() {
6102 // @@protoc_insertion_point(field_release:tensorflow.TestResults.target)
6103
6104 return target_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6105}
6106inline void TestResults::set_allocated_target(std::string* target) {
6107 if (target != nullptr) {
6108
6109 } else {
6110
6111 }
6112 target_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), target,
6113 GetArenaNoVirtual());
6114 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.target)
6115}
6116inline std::string* TestResults::unsafe_arena_release_target() {
6117 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.target)
6118 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6119
6120 return target_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6121 GetArenaNoVirtual());
6122}
6123inline void TestResults::unsafe_arena_set_allocated_target(
6124 std::string* target) {
6125 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6126 if (target != nullptr) {
6127
6128 } else {
6129
6130 }
6131 target_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6132 target, GetArenaNoVirtual());
6133 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.target)
6134}
6135
6136// .tensorflow.BenchmarkEntries entries = 2;
6137inline bool TestResults::has_entries() const {
6138 return this != internal_default_instance() && entries_ != nullptr;
6139}
6140inline void TestResults::clear_entries() {
6141 if (GetArenaNoVirtual() == nullptr && entries_ != nullptr) {
6142 delete entries_;
6143 }
6144 entries_ = nullptr;
6145}
6146inline const ::tensorflow::BenchmarkEntries& TestResults::entries() const {
6147 const ::tensorflow::BenchmarkEntries* p = entries_;
6148 // @@protoc_insertion_point(field_get:tensorflow.TestResults.entries)
6149 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::BenchmarkEntries*>(
6150 &::tensorflow::_BenchmarkEntries_default_instance_);
6151}
6152inline ::tensorflow::BenchmarkEntries* TestResults::release_entries() {
6153 // @@protoc_insertion_point(field_release:tensorflow.TestResults.entries)
6154
6155 ::tensorflow::BenchmarkEntries* temp = entries_;
6156 if (GetArenaNoVirtual() != nullptr) {
6157 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6158 }
6159 entries_ = nullptr;
6160 return temp;
6161}
6162inline ::tensorflow::BenchmarkEntries* TestResults::unsafe_arena_release_entries() {
6163 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.entries)
6164
6165 ::tensorflow::BenchmarkEntries* temp = entries_;
6166 entries_ = nullptr;
6167 return temp;
6168}
6169inline ::tensorflow::BenchmarkEntries* TestResults::mutable_entries() {
6170
6171 if (entries_ == nullptr) {
6172 auto* p = CreateMaybeMessage<::tensorflow::BenchmarkEntries>(GetArenaNoVirtual());
6173 entries_ = p;
6174 }
6175 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.entries)
6176 return entries_;
6177}
6178inline void TestResults::set_allocated_entries(::tensorflow::BenchmarkEntries* entries) {
6179 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6180 if (message_arena == nullptr) {
6181 delete entries_;
6182 }
6183 if (entries) {
6184 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6185 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(entries);
6186 if (message_arena != submessage_arena) {
6187 entries = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6188 message_arena, entries, submessage_arena);
6189 }
6190
6191 } else {
6192
6193 }
6194 entries_ = entries;
6195 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.entries)
6196}
6197
6198// .tensorflow.BuildConfiguration build_configuration = 3;
6199inline bool TestResults::has_build_configuration() const {
6200 return this != internal_default_instance() && build_configuration_ != nullptr;
6201}
6202inline void TestResults::clear_build_configuration() {
6203 if (GetArenaNoVirtual() == nullptr && build_configuration_ != nullptr) {
6204 delete build_configuration_;
6205 }
6206 build_configuration_ = nullptr;
6207}
6208inline const ::tensorflow::BuildConfiguration& TestResults::build_configuration() const {
6209 const ::tensorflow::BuildConfiguration* p = build_configuration_;
6210 // @@protoc_insertion_point(field_get:tensorflow.TestResults.build_configuration)
6211 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::BuildConfiguration*>(
6212 &::tensorflow::_BuildConfiguration_default_instance_);
6213}
6214inline ::tensorflow::BuildConfiguration* TestResults::release_build_configuration() {
6215 // @@protoc_insertion_point(field_release:tensorflow.TestResults.build_configuration)
6216
6217 ::tensorflow::BuildConfiguration* temp = build_configuration_;
6218 if (GetArenaNoVirtual() != nullptr) {
6219 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6220 }
6221 build_configuration_ = nullptr;
6222 return temp;
6223}
6224inline ::tensorflow::BuildConfiguration* TestResults::unsafe_arena_release_build_configuration() {
6225 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.build_configuration)
6226
6227 ::tensorflow::BuildConfiguration* temp = build_configuration_;
6228 build_configuration_ = nullptr;
6229 return temp;
6230}
6231inline ::tensorflow::BuildConfiguration* TestResults::mutable_build_configuration() {
6232
6233 if (build_configuration_ == nullptr) {
6234 auto* p = CreateMaybeMessage<::tensorflow::BuildConfiguration>(GetArenaNoVirtual());
6235 build_configuration_ = p;
6236 }
6237 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.build_configuration)
6238 return build_configuration_;
6239}
6240inline void TestResults::set_allocated_build_configuration(::tensorflow::BuildConfiguration* build_configuration) {
6241 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6242 if (message_arena == nullptr) {
6243 delete build_configuration_;
6244 }
6245 if (build_configuration) {
6246 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6247 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(build_configuration);
6248 if (message_arena != submessage_arena) {
6249 build_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6250 message_arena, build_configuration, submessage_arena);
6251 }
6252
6253 } else {
6254
6255 }
6256 build_configuration_ = build_configuration;
6257 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.build_configuration)
6258}
6259
6260// .tensorflow.CommitId commit_id = 4;
6261inline bool TestResults::has_commit_id() const {
6262 return this != internal_default_instance() && commit_id_ != nullptr;
6263}
6264inline void TestResults::clear_commit_id() {
6265 if (GetArenaNoVirtual() == nullptr && commit_id_ != nullptr) {
6266 delete commit_id_;
6267 }
6268 commit_id_ = nullptr;
6269}
6270inline const ::tensorflow::CommitId& TestResults::commit_id() const {
6271 const ::tensorflow::CommitId* p = commit_id_;
6272 // @@protoc_insertion_point(field_get:tensorflow.TestResults.commit_id)
6273 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CommitId*>(
6274 &::tensorflow::_CommitId_default_instance_);
6275}
6276inline ::tensorflow::CommitId* TestResults::release_commit_id() {
6277 // @@protoc_insertion_point(field_release:tensorflow.TestResults.commit_id)
6278
6279 ::tensorflow::CommitId* temp = commit_id_;
6280 if (GetArenaNoVirtual() != nullptr) {
6281 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6282 }
6283 commit_id_ = nullptr;
6284 return temp;
6285}
6286inline ::tensorflow::CommitId* TestResults::unsafe_arena_release_commit_id() {
6287 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.commit_id)
6288
6289 ::tensorflow::CommitId* temp = commit_id_;
6290 commit_id_ = nullptr;
6291 return temp;
6292}
6293inline ::tensorflow::CommitId* TestResults::mutable_commit_id() {
6294
6295 if (commit_id_ == nullptr) {
6296 auto* p = CreateMaybeMessage<::tensorflow::CommitId>(GetArenaNoVirtual());
6297 commit_id_ = p;
6298 }
6299 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.commit_id)
6300 return commit_id_;
6301}
6302inline void TestResults::set_allocated_commit_id(::tensorflow::CommitId* commit_id) {
6303 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6304 if (message_arena == nullptr) {
6305 delete commit_id_;
6306 }
6307 if (commit_id) {
6308 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6309 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(commit_id);
6310 if (message_arena != submessage_arena) {
6311 commit_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6312 message_arena, commit_id, submessage_arena);
6313 }
6314
6315 } else {
6316
6317 }
6318 commit_id_ = commit_id;
6319 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.commit_id)
6320}
6321
6322// int64 start_time = 5;
6323inline void TestResults::clear_start_time() {
6324 start_time_ = PROTOBUF_LONGLONG(0);
6325}
6326inline ::PROTOBUF_NAMESPACE_ID::int64 TestResults::start_time() const {
6327 // @@protoc_insertion_point(field_get:tensorflow.TestResults.start_time)
6328 return start_time_;
6329}
6330inline void TestResults::set_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
6331
6332 start_time_ = value;
6333 // @@protoc_insertion_point(field_set:tensorflow.TestResults.start_time)
6334}
6335
6336// double run_time = 6;
6337inline void TestResults::clear_run_time() {
6338 run_time_ = 0;
6339}
6340inline double TestResults::run_time() const {
6341 // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_time)
6342 return run_time_;
6343}
6344inline void TestResults::set_run_time(double value) {
6345
6346 run_time_ = value;
6347 // @@protoc_insertion_point(field_set:tensorflow.TestResults.run_time)
6348}
6349
6350// .tensorflow.MachineConfiguration machine_configuration = 7;
6351inline bool TestResults::has_machine_configuration() const {
6352 return this != internal_default_instance() && machine_configuration_ != nullptr;
6353}
6354inline void TestResults::clear_machine_configuration() {
6355 if (GetArenaNoVirtual() == nullptr && machine_configuration_ != nullptr) {
6356 delete machine_configuration_;
6357 }
6358 machine_configuration_ = nullptr;
6359}
6360inline const ::tensorflow::MachineConfiguration& TestResults::machine_configuration() const {
6361 const ::tensorflow::MachineConfiguration* p = machine_configuration_;
6362 // @@protoc_insertion_point(field_get:tensorflow.TestResults.machine_configuration)
6363 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::MachineConfiguration*>(
6364 &::tensorflow::_MachineConfiguration_default_instance_);
6365}
6366inline ::tensorflow::MachineConfiguration* TestResults::release_machine_configuration() {
6367 // @@protoc_insertion_point(field_release:tensorflow.TestResults.machine_configuration)
6368
6369 ::tensorflow::MachineConfiguration* temp = machine_configuration_;
6370 if (GetArenaNoVirtual() != nullptr) {
6371 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6372 }
6373 machine_configuration_ = nullptr;
6374 return temp;
6375}
6376inline ::tensorflow::MachineConfiguration* TestResults::unsafe_arena_release_machine_configuration() {
6377 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.machine_configuration)
6378
6379 ::tensorflow::MachineConfiguration* temp = machine_configuration_;
6380 machine_configuration_ = nullptr;
6381 return temp;
6382}
6383inline ::tensorflow::MachineConfiguration* TestResults::mutable_machine_configuration() {
6384
6385 if (machine_configuration_ == nullptr) {
6386 auto* p = CreateMaybeMessage<::tensorflow::MachineConfiguration>(GetArenaNoVirtual());
6387 machine_configuration_ = p;
6388 }
6389 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.machine_configuration)
6390 return machine_configuration_;
6391}
6392inline void TestResults::set_allocated_machine_configuration(::tensorflow::MachineConfiguration* machine_configuration) {
6393 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6394 if (message_arena == nullptr) {
6395 delete machine_configuration_;
6396 }
6397 if (machine_configuration) {
6398 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6399 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(machine_configuration);
6400 if (message_arena != submessage_arena) {
6401 machine_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6402 message_arena, machine_configuration, submessage_arena);
6403 }
6404
6405 } else {
6406
6407 }
6408 machine_configuration_ = machine_configuration;
6409 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.machine_configuration)
6410}
6411
6412// .tensorflow.RunConfiguration run_configuration = 8;
6413inline bool TestResults::has_run_configuration() const {
6414 return this != internal_default_instance() && run_configuration_ != nullptr;
6415}
6416inline void TestResults::clear_run_configuration() {
6417 if (GetArenaNoVirtual() == nullptr && run_configuration_ != nullptr) {
6418 delete run_configuration_;
6419 }
6420 run_configuration_ = nullptr;
6421}
6422inline const ::tensorflow::RunConfiguration& TestResults::run_configuration() const {
6423 const ::tensorflow::RunConfiguration* p = run_configuration_;
6424 // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_configuration)
6425 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::RunConfiguration*>(
6426 &::tensorflow::_RunConfiguration_default_instance_);
6427}
6428inline ::tensorflow::RunConfiguration* TestResults::release_run_configuration() {
6429 // @@protoc_insertion_point(field_release:tensorflow.TestResults.run_configuration)
6430
6431 ::tensorflow::RunConfiguration* temp = run_configuration_;
6432 if (GetArenaNoVirtual() != nullptr) {
6433 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6434 }
6435 run_configuration_ = nullptr;
6436 return temp;
6437}
6438inline ::tensorflow::RunConfiguration* TestResults::unsafe_arena_release_run_configuration() {
6439 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.run_configuration)
6440
6441 ::tensorflow::RunConfiguration* temp = run_configuration_;
6442 run_configuration_ = nullptr;
6443 return temp;
6444}
6445inline ::tensorflow::RunConfiguration* TestResults::mutable_run_configuration() {
6446
6447 if (run_configuration_ == nullptr) {
6448 auto* p = CreateMaybeMessage<::tensorflow::RunConfiguration>(GetArenaNoVirtual());
6449 run_configuration_ = p;
6450 }
6451 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.run_configuration)
6452 return run_configuration_;
6453}
6454inline void TestResults::set_allocated_run_configuration(::tensorflow::RunConfiguration* run_configuration) {
6455 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6456 if (message_arena == nullptr) {
6457 delete run_configuration_;
6458 }
6459 if (run_configuration) {
6460 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6461 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(run_configuration);
6462 if (message_arena != submessage_arena) {
6463 run_configuration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6464 message_arena, run_configuration, submessage_arena);
6465 }
6466
6467 } else {
6468
6469 }
6470 run_configuration_ = run_configuration;
6471 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.run_configuration)
6472}
6473
6474// string name = 9;
6475inline void TestResults::clear_name() {
6476 name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6477}
6478inline const std::string& TestResults::name() const {
6479 // @@protoc_insertion_point(field_get:tensorflow.TestResults.name)
6480 return name_.Get();
6481}
6482inline void TestResults::set_name(const std::string& value) {
6483
6484 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
6485 // @@protoc_insertion_point(field_set:tensorflow.TestResults.name)
6486}
6487inline void TestResults::set_name(std::string&& value) {
6488
6489 name_.Set(
6490 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
6491 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TestResults.name)
6492}
6493inline void TestResults::set_name(const char* value) {
6494 GOOGLE_DCHECK(value != nullptr);
6495
6496 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
6497 GetArenaNoVirtual());
6498 // @@protoc_insertion_point(field_set_char:tensorflow.TestResults.name)
6499}
6500inline void TestResults::set_name(const char* value,
6501 size_t size) {
6502
6503 name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
6504 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
6505 // @@protoc_insertion_point(field_set_pointer:tensorflow.TestResults.name)
6506}
6507inline std::string* TestResults::mutable_name() {
6508
6509 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.name)
6510 return name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6511}
6512inline std::string* TestResults::release_name() {
6513 // @@protoc_insertion_point(field_release:tensorflow.TestResults.name)
6514
6515 return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6516}
6517inline void TestResults::set_allocated_name(std::string* name) {
6518 if (name != nullptr) {
6519
6520 } else {
6521
6522 }
6523 name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
6524 GetArenaNoVirtual());
6525 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.name)
6526}
6527inline std::string* TestResults::unsafe_arena_release_name() {
6528 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.name)
6529 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6530
6531 return name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6532 GetArenaNoVirtual());
6533}
6534inline void TestResults::unsafe_arena_set_allocated_name(
6535 std::string* name) {
6536 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6537 if (name != nullptr) {
6538
6539 } else {
6540
6541 }
6542 name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6543 name, GetArenaNoVirtual());
6544 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.name)
6545}
6546
6547// .tensorflow.TestResults.BenchmarkType benchmark_type = 10;
6548inline void TestResults::clear_benchmark_type() {
6549 benchmark_type_ = 0;
6550}
6551inline ::tensorflow::TestResults_BenchmarkType TestResults::benchmark_type() const {
6552 // @@protoc_insertion_point(field_get:tensorflow.TestResults.benchmark_type)
6553 return static_cast< ::tensorflow::TestResults_BenchmarkType >(benchmark_type_);
6554}
6555inline void TestResults::set_benchmark_type(::tensorflow::TestResults_BenchmarkType value) {
6556
6557 benchmark_type_ = value;
6558 // @@protoc_insertion_point(field_set:tensorflow.TestResults.benchmark_type)
6559}
6560
6561// string run_mode = 11;
6562inline void TestResults::clear_run_mode() {
6563 run_mode_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6564}
6565inline const std::string& TestResults::run_mode() const {
6566 // @@protoc_insertion_point(field_get:tensorflow.TestResults.run_mode)
6567 return run_mode_.Get();
6568}
6569inline void TestResults::set_run_mode(const std::string& value) {
6570
6571 run_mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
6572 // @@protoc_insertion_point(field_set:tensorflow.TestResults.run_mode)
6573}
6574inline void TestResults::set_run_mode(std::string&& value) {
6575
6576 run_mode_.Set(
6577 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
6578 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TestResults.run_mode)
6579}
6580inline void TestResults::set_run_mode(const char* value) {
6581 GOOGLE_DCHECK(value != nullptr);
6582
6583 run_mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
6584 GetArenaNoVirtual());
6585 // @@protoc_insertion_point(field_set_char:tensorflow.TestResults.run_mode)
6586}
6587inline void TestResults::set_run_mode(const char* value,
6588 size_t size) {
6589
6590 run_mode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
6591 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
6592 // @@protoc_insertion_point(field_set_pointer:tensorflow.TestResults.run_mode)
6593}
6594inline std::string* TestResults::mutable_run_mode() {
6595
6596 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.run_mode)
6597 return run_mode_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6598}
6599inline std::string* TestResults::release_run_mode() {
6600 // @@protoc_insertion_point(field_release:tensorflow.TestResults.run_mode)
6601
6602 return run_mode_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6603}
6604inline void TestResults::set_allocated_run_mode(std::string* run_mode) {
6605 if (run_mode != nullptr) {
6606
6607 } else {
6608
6609 }
6610 run_mode_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), run_mode,
6611 GetArenaNoVirtual());
6612 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.run_mode)
6613}
6614inline std::string* TestResults::unsafe_arena_release_run_mode() {
6615 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.run_mode)
6616 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6617
6618 return run_mode_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6619 GetArenaNoVirtual());
6620}
6621inline void TestResults::unsafe_arena_set_allocated_run_mode(
6622 std::string* run_mode) {
6623 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6624 if (run_mode != nullptr) {
6625
6626 } else {
6627
6628 }
6629 run_mode_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6630 run_mode, GetArenaNoVirtual());
6631 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.run_mode)
6632}
6633
6634// string tf_version = 12;
6635inline void TestResults::clear_tf_version() {
6636 tf_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6637}
6638inline const std::string& TestResults::tf_version() const {
6639 // @@protoc_insertion_point(field_get:tensorflow.TestResults.tf_version)
6640 return tf_version_.Get();
6641}
6642inline void TestResults::set_tf_version(const std::string& value) {
6643
6644 tf_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
6645 // @@protoc_insertion_point(field_set:tensorflow.TestResults.tf_version)
6646}
6647inline void TestResults::set_tf_version(std::string&& value) {
6648
6649 tf_version_.Set(
6650 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
6651 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TestResults.tf_version)
6652}
6653inline void TestResults::set_tf_version(const char* value) {
6654 GOOGLE_DCHECK(value != nullptr);
6655
6656 tf_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
6657 GetArenaNoVirtual());
6658 // @@protoc_insertion_point(field_set_char:tensorflow.TestResults.tf_version)
6659}
6660inline void TestResults::set_tf_version(const char* value,
6661 size_t size) {
6662
6663 tf_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
6664 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
6665 // @@protoc_insertion_point(field_set_pointer:tensorflow.TestResults.tf_version)
6666}
6667inline std::string* TestResults::mutable_tf_version() {
6668
6669 // @@protoc_insertion_point(field_mutable:tensorflow.TestResults.tf_version)
6670 return tf_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6671}
6672inline std::string* TestResults::release_tf_version() {
6673 // @@protoc_insertion_point(field_release:tensorflow.TestResults.tf_version)
6674
6675 return tf_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
6676}
6677inline void TestResults::set_allocated_tf_version(std::string* tf_version) {
6678 if (tf_version != nullptr) {
6679
6680 } else {
6681
6682 }
6683 tf_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tf_version,
6684 GetArenaNoVirtual());
6685 // @@protoc_insertion_point(field_set_allocated:tensorflow.TestResults.tf_version)
6686}
6687inline std::string* TestResults::unsafe_arena_release_tf_version() {
6688 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.TestResults.tf_version)
6689 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6690
6691 return tf_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6692 GetArenaNoVirtual());
6693}
6694inline void TestResults::unsafe_arena_set_allocated_tf_version(
6695 std::string* tf_version) {
6696 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
6697 if (tf_version != nullptr) {
6698
6699 } else {
6700
6701 }
6702 tf_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6703 tf_version, GetArenaNoVirtual());
6704 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TestResults.tf_version)
6705}
6706
6707#ifdef __GNUC__
6708 #pragma GCC diagnostic pop
6709#endif // __GNUC__
6710// -------------------------------------------------------------------
6711
6712// -------------------------------------------------------------------
6713
6714// -------------------------------------------------------------------
6715
6716// -------------------------------------------------------------------
6717
6718// -------------------------------------------------------------------
6719
6720// -------------------------------------------------------------------
6721
6722// -------------------------------------------------------------------
6723
6724// -------------------------------------------------------------------
6725
6726// -------------------------------------------------------------------
6727
6728// -------------------------------------------------------------------
6729
6730// -------------------------------------------------------------------
6731
6732// -------------------------------------------------------------------
6733
6734// -------------------------------------------------------------------
6735
6736// -------------------------------------------------------------------
6737
6738// -------------------------------------------------------------------
6739
6740// -------------------------------------------------------------------
6741
6742
6743// @@protoc_insertion_point(namespace_scope)
6744
6745} // namespace tensorflow
6746
6747PROTOBUF_NAMESPACE_OPEN
6748
6749template <> struct is_proto_enum< ::tensorflow::TestResults_BenchmarkType> : ::std::true_type {};
6750template <>
6751inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::TestResults_BenchmarkType>() {
6752 return ::tensorflow::TestResults_BenchmarkType_descriptor();
6753}
6754
6755PROTOBUF_NAMESPACE_CLOSE
6756
6757// @@protoc_insertion_point(global_scope)
6758
6759#include <google/protobuf/port_undef.inc>
6760#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2futil_2ftest_5flog_2eproto
6761