1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: packages/modules/adb/proto/adb_host.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/generated_message_reflection.h>
30 #include <google/protobuf/message.h>
31 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
32 #include <google/protobuf/extension_set.h> // IWYU pragma: export
33 #include <google/protobuf/generated_enum_reflection.h>
34 #include <google/protobuf/unknown_field_set.h>
35 // @@protoc_insertion_point(includes)
36 #include <google/protobuf/port_def.inc>
37 #define PROTOBUF_INTERNAL_EXPORT_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto
38 PROTOBUF_NAMESPACE_OPEN
39 namespace internal {
40 class AnyMetadata;
41 } // namespace internal
42 PROTOBUF_NAMESPACE_CLOSE
43
44 // Internal implementation detail -- do not use these members.
45 struct TableStruct_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto {
46 static const ::uint32_t offsets[];
47 };
48 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto;
49 namespace adb {
50 namespace proto {
51 class AdbServerStatus;
52 struct AdbServerStatusDefaultTypeInternal;
53 extern AdbServerStatusDefaultTypeInternal _AdbServerStatus_default_instance_;
54 class Device;
55 struct DeviceDefaultTypeInternal;
56 extern DeviceDefaultTypeInternal _Device_default_instance_;
57 class Devices;
58 struct DevicesDefaultTypeInternal;
59 extern DevicesDefaultTypeInternal _Devices_default_instance_;
60 } // namespace proto
61 } // namespace adb
62 PROTOBUF_NAMESPACE_OPEN
63 template<> ::adb::proto::AdbServerStatus* Arena::CreateMaybeMessage<::adb::proto::AdbServerStatus>(Arena*);
64 template<> ::adb::proto::Device* Arena::CreateMaybeMessage<::adb::proto::Device>(Arena*);
65 template<> ::adb::proto::Devices* Arena::CreateMaybeMessage<::adb::proto::Devices>(Arena*);
66 PROTOBUF_NAMESPACE_CLOSE
67 namespace adb {
68 namespace proto {
69
70 enum AdbServerStatus_UsbBackend : int {
71 AdbServerStatus_UsbBackend_UNKNOWN_USB = 0,
72 AdbServerStatus_UsbBackend_NATIVE = 1,
73 AdbServerStatus_UsbBackend_LIBUSB = 2,
74 AdbServerStatus_UsbBackend_AdbServerStatus_UsbBackend_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
75 AdbServerStatus_UsbBackend_AdbServerStatus_UsbBackend_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
76 };
77 bool AdbServerStatus_UsbBackend_IsValid(int value);
78 constexpr AdbServerStatus_UsbBackend AdbServerStatus_UsbBackend_UsbBackend_MIN = AdbServerStatus_UsbBackend_UNKNOWN_USB;
79 constexpr AdbServerStatus_UsbBackend AdbServerStatus_UsbBackend_UsbBackend_MAX = AdbServerStatus_UsbBackend_LIBUSB;
80 constexpr int AdbServerStatus_UsbBackend_UsbBackend_ARRAYSIZE = AdbServerStatus_UsbBackend_UsbBackend_MAX + 1;
81
82 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AdbServerStatus_UsbBackend_descriptor();
83 template<typename T>
AdbServerStatus_UsbBackend_Name(T enum_t_value)84 inline const std::string& AdbServerStatus_UsbBackend_Name(T enum_t_value) {
85 static_assert(::std::is_same<T, AdbServerStatus_UsbBackend>::value ||
86 ::std::is_integral<T>::value,
87 "Incorrect type passed to function AdbServerStatus_UsbBackend_Name.");
88 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
89 AdbServerStatus_UsbBackend_descriptor(), enum_t_value);
90 }
AdbServerStatus_UsbBackend_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,AdbServerStatus_UsbBackend * value)91 inline bool AdbServerStatus_UsbBackend_Parse(
92 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AdbServerStatus_UsbBackend* value) {
93 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AdbServerStatus_UsbBackend>(
94 AdbServerStatus_UsbBackend_descriptor(), name, value);
95 }
96 enum AdbServerStatus_MdnsBackend : int {
97 AdbServerStatus_MdnsBackend_UNKNOWN_MDNS = 0,
98 AdbServerStatus_MdnsBackend_BONJOUR = 1,
99 AdbServerStatus_MdnsBackend_OPENSCREEN = 2,
100 AdbServerStatus_MdnsBackend_AdbServerStatus_MdnsBackend_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
101 AdbServerStatus_MdnsBackend_AdbServerStatus_MdnsBackend_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
102 };
103 bool AdbServerStatus_MdnsBackend_IsValid(int value);
104 constexpr AdbServerStatus_MdnsBackend AdbServerStatus_MdnsBackend_MdnsBackend_MIN = AdbServerStatus_MdnsBackend_UNKNOWN_MDNS;
105 constexpr AdbServerStatus_MdnsBackend AdbServerStatus_MdnsBackend_MdnsBackend_MAX = AdbServerStatus_MdnsBackend_OPENSCREEN;
106 constexpr int AdbServerStatus_MdnsBackend_MdnsBackend_ARRAYSIZE = AdbServerStatus_MdnsBackend_MdnsBackend_MAX + 1;
107
108 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AdbServerStatus_MdnsBackend_descriptor();
109 template<typename T>
AdbServerStatus_MdnsBackend_Name(T enum_t_value)110 inline const std::string& AdbServerStatus_MdnsBackend_Name(T enum_t_value) {
111 static_assert(::std::is_same<T, AdbServerStatus_MdnsBackend>::value ||
112 ::std::is_integral<T>::value,
113 "Incorrect type passed to function AdbServerStatus_MdnsBackend_Name.");
114 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
115 AdbServerStatus_MdnsBackend_descriptor(), enum_t_value);
116 }
AdbServerStatus_MdnsBackend_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,AdbServerStatus_MdnsBackend * value)117 inline bool AdbServerStatus_MdnsBackend_Parse(
118 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AdbServerStatus_MdnsBackend* value) {
119 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<AdbServerStatus_MdnsBackend>(
120 AdbServerStatus_MdnsBackend_descriptor(), name, value);
121 }
122 enum ConnectionState : int {
123 ANY = 0,
124 CONNECTING = 1,
125 AUTHORIZING = 2,
126 UNAUTHORIZED = 3,
127 NOPERMISSION = 4,
128 DETACHED = 5,
129 OFFLINE = 6,
130 BOOTLOADER = 7,
131 DEVICE = 8,
132 HOST = 9,
133 RECOVERY = 10,
134 SIDELOAD = 11,
135 RESCUE = 12,
136 ConnectionState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
137 ConnectionState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
138 };
139 bool ConnectionState_IsValid(int value);
140 constexpr ConnectionState ConnectionState_MIN = ANY;
141 constexpr ConnectionState ConnectionState_MAX = RESCUE;
142 constexpr int ConnectionState_ARRAYSIZE = ConnectionState_MAX + 1;
143
144 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConnectionState_descriptor();
145 template<typename T>
ConnectionState_Name(T enum_t_value)146 inline const std::string& ConnectionState_Name(T enum_t_value) {
147 static_assert(::std::is_same<T, ConnectionState>::value ||
148 ::std::is_integral<T>::value,
149 "Incorrect type passed to function ConnectionState_Name.");
150 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
151 ConnectionState_descriptor(), enum_t_value);
152 }
ConnectionState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ConnectionState * value)153 inline bool ConnectionState_Parse(
154 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionState* value) {
155 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConnectionState>(
156 ConnectionState_descriptor(), name, value);
157 }
158 enum ConnectionType : int {
159 UNKNOWN = 0,
160 USB = 1,
161 SOCKET = 2,
162 ConnectionType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
163 ConnectionType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
164 };
165 bool ConnectionType_IsValid(int value);
166 constexpr ConnectionType ConnectionType_MIN = UNKNOWN;
167 constexpr ConnectionType ConnectionType_MAX = SOCKET;
168 constexpr int ConnectionType_ARRAYSIZE = ConnectionType_MAX + 1;
169
170 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ConnectionType_descriptor();
171 template<typename T>
ConnectionType_Name(T enum_t_value)172 inline const std::string& ConnectionType_Name(T enum_t_value) {
173 static_assert(::std::is_same<T, ConnectionType>::value ||
174 ::std::is_integral<T>::value,
175 "Incorrect type passed to function ConnectionType_Name.");
176 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
177 ConnectionType_descriptor(), enum_t_value);
178 }
ConnectionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ConnectionType * value)179 inline bool ConnectionType_Parse(
180 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConnectionType* value) {
181 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ConnectionType>(
182 ConnectionType_descriptor(), name, value);
183 }
184 // ===================================================================
185
186 class Device final :
187 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:adb.proto.Device) */ {
188 public:
Device()189 inline Device() : Device(nullptr) {}
190 ~Device() override;
191 explicit PROTOBUF_CONSTEXPR Device(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
192
193 Device(const Device& from);
Device(Device && from)194 Device(Device&& from) noexcept
195 : Device() {
196 *this = ::std::move(from);
197 }
198
199 inline Device& operator=(const Device& from) {
200 if (this == &from) return *this;
201 CopyFrom(from);
202 return *this;
203 }
204 inline Device& operator=(Device&& from) noexcept {
205 if (this == &from) return *this;
206 if (GetOwningArena() == from.GetOwningArena()
207 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
208 && GetOwningArena() != nullptr
209 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
210 ) {
211 InternalSwap(&from);
212 } else {
213 CopyFrom(from);
214 }
215 return *this;
216 }
217
descriptor()218 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
219 return GetDescriptor();
220 }
GetDescriptor()221 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
222 return default_instance().GetMetadata().descriptor;
223 }
GetReflection()224 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
225 return default_instance().GetMetadata().reflection;
226 }
default_instance()227 static const Device& default_instance() {
228 return *internal_default_instance();
229 }
internal_default_instance()230 static inline const Device* internal_default_instance() {
231 return reinterpret_cast<const Device*>(
232 &_Device_default_instance_);
233 }
234 static constexpr int kIndexInFileMessages =
235 0;
236
swap(Device & a,Device & b)237 friend void swap(Device& a, Device& b) {
238 a.Swap(&b);
239 }
Swap(Device * other)240 inline void Swap(Device* other) {
241 if (other == this) return;
242 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
243 if (GetOwningArena() != nullptr &&
244 GetOwningArena() == other->GetOwningArena()) {
245 #else // PROTOBUF_FORCE_COPY_IN_SWAP
246 if (GetOwningArena() == other->GetOwningArena()) {
247 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
248 InternalSwap(other);
249 } else {
250 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
251 }
252 }
253 void UnsafeArenaSwap(Device* other) {
254 if (other == this) return;
255 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
256 InternalSwap(other);
257 }
258
259 // implements Message ----------------------------------------------
260
261 Device* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
262 return CreateMaybeMessage<Device>(arena);
263 }
264 Device* New() const {
265 return New(nullptr);
266 }
267 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
268 void CopyFrom(const Device& from);
269 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
270 void MergeFrom( const Device& from) {
271 Device::MergeImpl(*this, from);
272 }
273 private:
274 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
275 public:
276 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
277 bool IsInitialized() const final;
278
279 size_t ByteSizeLong() const final;
280 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
281 ::uint8_t* _InternalSerialize(
282 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
283 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
284
285 private:
286 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
287 void SharedDtor();
288 void SetCachedSize(int size) const final;
289 void InternalSwap(Device* other);
290
291 private:
292 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
293 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
294 return "adb.proto.Device";
295 }
296 protected:
297 explicit Device(::PROTOBUF_NAMESPACE_ID::Arena* arena,
298 bool is_message_owned = false);
299 public:
300
301 static const ClassData _class_data_;
302 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
303
304 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
305
306 // nested types ----------------------------------------------------
307
308 // accessors -------------------------------------------------------
309
310 enum : int {
311 kSerialFieldNumber = 1,
312 kBusAddressFieldNumber = 3,
313 kProductFieldNumber = 4,
314 kModelFieldNumber = 5,
315 kDeviceFieldNumber = 6,
316 kStateFieldNumber = 2,
317 kConnectionTypeFieldNumber = 7,
318 kNegotiatedSpeedFieldNumber = 8,
319 kMaxSpeedFieldNumber = 9,
320 kTransportIdFieldNumber = 10,
321 };
322 // string serial = 1;
323 void clear_serial();
324 const std::string& serial() const;
325 template <typename ArgT0 = const std::string&, typename... ArgT>
326 void set_serial(ArgT0&& arg0, ArgT... args);
327 std::string* mutable_serial();
328 PROTOBUF_NODISCARD std::string* release_serial();
329 void set_allocated_serial(std::string* serial);
330 private:
331 const std::string& _internal_serial() const;
332 inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial(const std::string& value);
333 std::string* _internal_mutable_serial();
334 public:
335
336 // string bus_address = 3;
337 void clear_bus_address();
338 const std::string& bus_address() const;
339 template <typename ArgT0 = const std::string&, typename... ArgT>
340 void set_bus_address(ArgT0&& arg0, ArgT... args);
341 std::string* mutable_bus_address();
342 PROTOBUF_NODISCARD std::string* release_bus_address();
343 void set_allocated_bus_address(std::string* bus_address);
344 private:
345 const std::string& _internal_bus_address() const;
346 inline PROTOBUF_ALWAYS_INLINE void _internal_set_bus_address(const std::string& value);
347 std::string* _internal_mutable_bus_address();
348 public:
349
350 // string product = 4;
351 void clear_product();
352 const std::string& product() const;
353 template <typename ArgT0 = const std::string&, typename... ArgT>
354 void set_product(ArgT0&& arg0, ArgT... args);
355 std::string* mutable_product();
356 PROTOBUF_NODISCARD std::string* release_product();
357 void set_allocated_product(std::string* product);
358 private:
359 const std::string& _internal_product() const;
360 inline PROTOBUF_ALWAYS_INLINE void _internal_set_product(const std::string& value);
361 std::string* _internal_mutable_product();
362 public:
363
364 // string model = 5;
365 void clear_model();
366 const std::string& model() const;
367 template <typename ArgT0 = const std::string&, typename... ArgT>
368 void set_model(ArgT0&& arg0, ArgT... args);
369 std::string* mutable_model();
370 PROTOBUF_NODISCARD std::string* release_model();
371 void set_allocated_model(std::string* model);
372 private:
373 const std::string& _internal_model() const;
374 inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
375 std::string* _internal_mutable_model();
376 public:
377
378 // string device = 6;
379 void clear_device();
380 const std::string& device() const;
381 template <typename ArgT0 = const std::string&, typename... ArgT>
382 void set_device(ArgT0&& arg0, ArgT... args);
383 std::string* mutable_device();
384 PROTOBUF_NODISCARD std::string* release_device();
385 void set_allocated_device(std::string* device);
386 private:
387 const std::string& _internal_device() const;
388 inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
389 std::string* _internal_mutable_device();
390 public:
391
392 // .adb.proto.ConnectionState state = 2;
393 void clear_state();
394 ::adb::proto::ConnectionState state() const;
395 void set_state(::adb::proto::ConnectionState value);
396 private:
397 ::adb::proto::ConnectionState _internal_state() const;
398 void _internal_set_state(::adb::proto::ConnectionState value);
399 public:
400
401 // .adb.proto.ConnectionType connection_type = 7;
402 void clear_connection_type();
403 ::adb::proto::ConnectionType connection_type() const;
404 void set_connection_type(::adb::proto::ConnectionType value);
405 private:
406 ::adb::proto::ConnectionType _internal_connection_type() const;
407 void _internal_set_connection_type(::adb::proto::ConnectionType value);
408 public:
409
410 // int64 negotiated_speed = 8;
411 void clear_negotiated_speed();
412 ::int64_t negotiated_speed() const;
413 void set_negotiated_speed(::int64_t value);
414 private:
415 ::int64_t _internal_negotiated_speed() const;
416 void _internal_set_negotiated_speed(::int64_t value);
417 public:
418
419 // int64 max_speed = 9;
420 void clear_max_speed();
421 ::int64_t max_speed() const;
422 void set_max_speed(::int64_t value);
423 private:
424 ::int64_t _internal_max_speed() const;
425 void _internal_set_max_speed(::int64_t value);
426 public:
427
428 // int64 transport_id = 10;
429 void clear_transport_id();
430 ::int64_t transport_id() const;
431 void set_transport_id(::int64_t value);
432 private:
433 ::int64_t _internal_transport_id() const;
434 void _internal_set_transport_id(::int64_t value);
435 public:
436
437 // @@protoc_insertion_point(class_scope:adb.proto.Device)
438 private:
439 class _Internal;
440
441 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
442 typedef void InternalArenaConstructable_;
443 typedef void DestructorSkippable_;
444 struct Impl_ {
445 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_;
446 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bus_address_;
447 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_;
448 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
449 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
450 int state_;
451 int connection_type_;
452 ::int64_t negotiated_speed_;
453 ::int64_t max_speed_;
454 ::int64_t transport_id_;
455 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
456 };
457 union { Impl_ _impl_; };
458 friend struct ::TableStruct_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto;
459 };
460 // -------------------------------------------------------------------
461
462 class Devices final :
463 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:adb.proto.Devices) */ {
464 public:
Devices()465 inline Devices() : Devices(nullptr) {}
466 ~Devices() override;
467 explicit PROTOBUF_CONSTEXPR Devices(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
468
469 Devices(const Devices& from);
Devices(Devices && from)470 Devices(Devices&& from) noexcept
471 : Devices() {
472 *this = ::std::move(from);
473 }
474
475 inline Devices& operator=(const Devices& from) {
476 if (this == &from) return *this;
477 CopyFrom(from);
478 return *this;
479 }
480 inline Devices& operator=(Devices&& from) noexcept {
481 if (this == &from) return *this;
482 if (GetOwningArena() == from.GetOwningArena()
483 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
484 && GetOwningArena() != nullptr
485 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
486 ) {
487 InternalSwap(&from);
488 } else {
489 CopyFrom(from);
490 }
491 return *this;
492 }
493
descriptor()494 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
495 return GetDescriptor();
496 }
GetDescriptor()497 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
498 return default_instance().GetMetadata().descriptor;
499 }
GetReflection()500 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
501 return default_instance().GetMetadata().reflection;
502 }
default_instance()503 static const Devices& default_instance() {
504 return *internal_default_instance();
505 }
internal_default_instance()506 static inline const Devices* internal_default_instance() {
507 return reinterpret_cast<const Devices*>(
508 &_Devices_default_instance_);
509 }
510 static constexpr int kIndexInFileMessages =
511 1;
512
swap(Devices & a,Devices & b)513 friend void swap(Devices& a, Devices& b) {
514 a.Swap(&b);
515 }
Swap(Devices * other)516 inline void Swap(Devices* other) {
517 if (other == this) return;
518 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
519 if (GetOwningArena() != nullptr &&
520 GetOwningArena() == other->GetOwningArena()) {
521 #else // PROTOBUF_FORCE_COPY_IN_SWAP
522 if (GetOwningArena() == other->GetOwningArena()) {
523 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
524 InternalSwap(other);
525 } else {
526 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
527 }
528 }
529 void UnsafeArenaSwap(Devices* other) {
530 if (other == this) return;
531 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
532 InternalSwap(other);
533 }
534
535 // implements Message ----------------------------------------------
536
537 Devices* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
538 return CreateMaybeMessage<Devices>(arena);
539 }
540 Devices* New() const {
541 return New(nullptr);
542 }
543 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
544 void CopyFrom(const Devices& from);
545 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
546 void MergeFrom( const Devices& from) {
547 Devices::MergeImpl(*this, from);
548 }
549 private:
550 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
551 public:
552 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
553 bool IsInitialized() const final;
554
555 size_t ByteSizeLong() const final;
556 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
557 ::uint8_t* _InternalSerialize(
558 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
559 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
560
561 private:
562 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
563 void SharedDtor();
564 void SetCachedSize(int size) const final;
565 void InternalSwap(Devices* other);
566
567 private:
568 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
569 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
570 return "adb.proto.Devices";
571 }
572 protected:
573 explicit Devices(::PROTOBUF_NAMESPACE_ID::Arena* arena,
574 bool is_message_owned = false);
575 public:
576
577 static const ClassData _class_data_;
578 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
579
580 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
581
582 // nested types ----------------------------------------------------
583
584 // accessors -------------------------------------------------------
585
586 enum : int {
587 kDeviceFieldNumber = 1,
588 };
589 // repeated .adb.proto.Device device = 1;
590 int device_size() const;
591 private:
592 int _internal_device_size() const;
593 public:
594 void clear_device();
595 ::adb::proto::Device* mutable_device(int index);
596 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::adb::proto::Device >*
597 mutable_device();
598 private:
599 const ::adb::proto::Device& _internal_device(int index) const;
600 ::adb::proto::Device* _internal_add_device();
601 public:
602 const ::adb::proto::Device& device(int index) const;
603 ::adb::proto::Device* add_device();
604 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::adb::proto::Device >&
605 device() const;
606
607 // @@protoc_insertion_point(class_scope:adb.proto.Devices)
608 private:
609 class _Internal;
610
611 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
612 typedef void InternalArenaConstructable_;
613 typedef void DestructorSkippable_;
614 struct Impl_ {
615 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::adb::proto::Device > device_;
616 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
617 };
618 union { Impl_ _impl_; };
619 friend struct ::TableStruct_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto;
620 };
621 // -------------------------------------------------------------------
622
623 class AdbServerStatus final :
624 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:adb.proto.AdbServerStatus) */ {
625 public:
AdbServerStatus()626 inline AdbServerStatus() : AdbServerStatus(nullptr) {}
627 ~AdbServerStatus() override;
628 explicit PROTOBUF_CONSTEXPR AdbServerStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
629
630 AdbServerStatus(const AdbServerStatus& from);
AdbServerStatus(AdbServerStatus && from)631 AdbServerStatus(AdbServerStatus&& from) noexcept
632 : AdbServerStatus() {
633 *this = ::std::move(from);
634 }
635
636 inline AdbServerStatus& operator=(const AdbServerStatus& from) {
637 if (this == &from) return *this;
638 CopyFrom(from);
639 return *this;
640 }
641 inline AdbServerStatus& operator=(AdbServerStatus&& from) noexcept {
642 if (this == &from) return *this;
643 if (GetOwningArena() == from.GetOwningArena()
644 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
645 && GetOwningArena() != nullptr
646 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
647 ) {
648 InternalSwap(&from);
649 } else {
650 CopyFrom(from);
651 }
652 return *this;
653 }
654
descriptor()655 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
656 return GetDescriptor();
657 }
GetDescriptor()658 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
659 return default_instance().GetMetadata().descriptor;
660 }
GetReflection()661 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
662 return default_instance().GetMetadata().reflection;
663 }
default_instance()664 static const AdbServerStatus& default_instance() {
665 return *internal_default_instance();
666 }
internal_default_instance()667 static inline const AdbServerStatus* internal_default_instance() {
668 return reinterpret_cast<const AdbServerStatus*>(
669 &_AdbServerStatus_default_instance_);
670 }
671 static constexpr int kIndexInFileMessages =
672 2;
673
swap(AdbServerStatus & a,AdbServerStatus & b)674 friend void swap(AdbServerStatus& a, AdbServerStatus& b) {
675 a.Swap(&b);
676 }
Swap(AdbServerStatus * other)677 inline void Swap(AdbServerStatus* other) {
678 if (other == this) return;
679 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
680 if (GetOwningArena() != nullptr &&
681 GetOwningArena() == other->GetOwningArena()) {
682 #else // PROTOBUF_FORCE_COPY_IN_SWAP
683 if (GetOwningArena() == other->GetOwningArena()) {
684 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
685 InternalSwap(other);
686 } else {
687 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
688 }
689 }
690 void UnsafeArenaSwap(AdbServerStatus* other) {
691 if (other == this) return;
692 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
693 InternalSwap(other);
694 }
695
696 // implements Message ----------------------------------------------
697
698 AdbServerStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
699 return CreateMaybeMessage<AdbServerStatus>(arena);
700 }
701 AdbServerStatus* New() const {
702 return New(nullptr);
703 }
704 using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
705 void CopyFrom(const AdbServerStatus& from);
706 using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
707 void MergeFrom( const AdbServerStatus& from) {
708 AdbServerStatus::MergeImpl(*this, from);
709 }
710 private:
711 static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
712 public:
713 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
714 bool IsInitialized() const final;
715
716 size_t ByteSizeLong() const final;
717 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
718 ::uint8_t* _InternalSerialize(
719 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
720 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
721
722 private:
723 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
724 void SharedDtor();
725 void SetCachedSize(int size) const final;
726 void InternalSwap(AdbServerStatus* other);
727
728 private:
729 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
730 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
731 return "adb.proto.AdbServerStatus";
732 }
733 protected:
734 explicit AdbServerStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
735 bool is_message_owned = false);
736 public:
737
738 static const ClassData _class_data_;
739 const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
740
741 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
742
743 // nested types ----------------------------------------------------
744
745 typedef AdbServerStatus_UsbBackend UsbBackend;
746 static constexpr UsbBackend UNKNOWN_USB =
747 AdbServerStatus_UsbBackend_UNKNOWN_USB;
748 static constexpr UsbBackend NATIVE =
749 AdbServerStatus_UsbBackend_NATIVE;
750 static constexpr UsbBackend LIBUSB =
751 AdbServerStatus_UsbBackend_LIBUSB;
752 static inline bool UsbBackend_IsValid(int value) {
753 return AdbServerStatus_UsbBackend_IsValid(value);
754 }
755 static constexpr UsbBackend UsbBackend_MIN =
756 AdbServerStatus_UsbBackend_UsbBackend_MIN;
757 static constexpr UsbBackend UsbBackend_MAX =
758 AdbServerStatus_UsbBackend_UsbBackend_MAX;
759 static constexpr int UsbBackend_ARRAYSIZE =
760 AdbServerStatus_UsbBackend_UsbBackend_ARRAYSIZE;
761 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
762 UsbBackend_descriptor() {
763 return AdbServerStatus_UsbBackend_descriptor();
764 }
765 template<typename T>
766 static inline const std::string& UsbBackend_Name(T enum_t_value) {
767 static_assert(::std::is_same<T, UsbBackend>::value ||
768 ::std::is_integral<T>::value,
769 "Incorrect type passed to function UsbBackend_Name.");
770 return AdbServerStatus_UsbBackend_Name(enum_t_value);
771 }
772 static inline bool UsbBackend_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
773 UsbBackend* value) {
774 return AdbServerStatus_UsbBackend_Parse(name, value);
775 }
776
777 typedef AdbServerStatus_MdnsBackend MdnsBackend;
778 static constexpr MdnsBackend UNKNOWN_MDNS =
779 AdbServerStatus_MdnsBackend_UNKNOWN_MDNS;
780 static constexpr MdnsBackend BONJOUR =
781 AdbServerStatus_MdnsBackend_BONJOUR;
782 static constexpr MdnsBackend OPENSCREEN =
783 AdbServerStatus_MdnsBackend_OPENSCREEN;
784 static inline bool MdnsBackend_IsValid(int value) {
785 return AdbServerStatus_MdnsBackend_IsValid(value);
786 }
787 static constexpr MdnsBackend MdnsBackend_MIN =
788 AdbServerStatus_MdnsBackend_MdnsBackend_MIN;
789 static constexpr MdnsBackend MdnsBackend_MAX =
790 AdbServerStatus_MdnsBackend_MdnsBackend_MAX;
791 static constexpr int MdnsBackend_ARRAYSIZE =
792 AdbServerStatus_MdnsBackend_MdnsBackend_ARRAYSIZE;
793 static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
794 MdnsBackend_descriptor() {
795 return AdbServerStatus_MdnsBackend_descriptor();
796 }
797 template<typename T>
798 static inline const std::string& MdnsBackend_Name(T enum_t_value) {
799 static_assert(::std::is_same<T, MdnsBackend>::value ||
800 ::std::is_integral<T>::value,
801 "Incorrect type passed to function MdnsBackend_Name.");
802 return AdbServerStatus_MdnsBackend_Name(enum_t_value);
803 }
804 static inline bool MdnsBackend_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
805 MdnsBackend* value) {
806 return AdbServerStatus_MdnsBackend_Parse(name, value);
807 }
808
809 // accessors -------------------------------------------------------
810
811 enum : int {
812 kVersionFieldNumber = 5,
813 kBuildFieldNumber = 6,
814 kExecutableAbsolutePathFieldNumber = 7,
815 kLogAbsolutePathFieldNumber = 8,
816 kOsFieldNumber = 9,
817 kUsbBackendFieldNumber = 1,
818 kMdnsBackendFieldNumber = 3,
819 kUsbBackendForcedFieldNumber = 2,
820 kMdnsBackendForcedFieldNumber = 4,
821 };
822 // string version = 5;
823 void clear_version();
824 const std::string& version() const;
825 template <typename ArgT0 = const std::string&, typename... ArgT>
826 void set_version(ArgT0&& arg0, ArgT... args);
827 std::string* mutable_version();
828 PROTOBUF_NODISCARD std::string* release_version();
829 void set_allocated_version(std::string* version);
830 private:
831 const std::string& _internal_version() const;
832 inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
833 std::string* _internal_mutable_version();
834 public:
835
836 // string build = 6;
837 void clear_build();
838 const std::string& build() const;
839 template <typename ArgT0 = const std::string&, typename... ArgT>
840 void set_build(ArgT0&& arg0, ArgT... args);
841 std::string* mutable_build();
842 PROTOBUF_NODISCARD std::string* release_build();
843 void set_allocated_build(std::string* build);
844 private:
845 const std::string& _internal_build() const;
846 inline PROTOBUF_ALWAYS_INLINE void _internal_set_build(const std::string& value);
847 std::string* _internal_mutable_build();
848 public:
849
850 // string executable_absolute_path = 7;
851 void clear_executable_absolute_path();
852 const std::string& executable_absolute_path() const;
853 template <typename ArgT0 = const std::string&, typename... ArgT>
854 void set_executable_absolute_path(ArgT0&& arg0, ArgT... args);
855 std::string* mutable_executable_absolute_path();
856 PROTOBUF_NODISCARD std::string* release_executable_absolute_path();
857 void set_allocated_executable_absolute_path(std::string* executable_absolute_path);
858 private:
859 const std::string& _internal_executable_absolute_path() const;
860 inline PROTOBUF_ALWAYS_INLINE void _internal_set_executable_absolute_path(const std::string& value);
861 std::string* _internal_mutable_executable_absolute_path();
862 public:
863
864 // string log_absolute_path = 8;
865 void clear_log_absolute_path();
866 const std::string& log_absolute_path() const;
867 template <typename ArgT0 = const std::string&, typename... ArgT>
868 void set_log_absolute_path(ArgT0&& arg0, ArgT... args);
869 std::string* mutable_log_absolute_path();
870 PROTOBUF_NODISCARD std::string* release_log_absolute_path();
871 void set_allocated_log_absolute_path(std::string* log_absolute_path);
872 private:
873 const std::string& _internal_log_absolute_path() const;
874 inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_absolute_path(const std::string& value);
875 std::string* _internal_mutable_log_absolute_path();
876 public:
877
878 // string os = 9;
879 void clear_os();
880 const std::string& os() const;
881 template <typename ArgT0 = const std::string&, typename... ArgT>
882 void set_os(ArgT0&& arg0, ArgT... args);
883 std::string* mutable_os();
884 PROTOBUF_NODISCARD std::string* release_os();
885 void set_allocated_os(std::string* os);
886 private:
887 const std::string& _internal_os() const;
888 inline PROTOBUF_ALWAYS_INLINE void _internal_set_os(const std::string& value);
889 std::string* _internal_mutable_os();
890 public:
891
892 // .adb.proto.AdbServerStatus.UsbBackend usb_backend = 1;
893 void clear_usb_backend();
894 ::adb::proto::AdbServerStatus_UsbBackend usb_backend() const;
895 void set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value);
896 private:
897 ::adb::proto::AdbServerStatus_UsbBackend _internal_usb_backend() const;
898 void _internal_set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value);
899 public:
900
901 // .adb.proto.AdbServerStatus.MdnsBackend mdns_backend = 3;
902 void clear_mdns_backend();
903 ::adb::proto::AdbServerStatus_MdnsBackend mdns_backend() const;
904 void set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value);
905 private:
906 ::adb::proto::AdbServerStatus_MdnsBackend _internal_mdns_backend() const;
907 void _internal_set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value);
908 public:
909
910 // bool usb_backend_forced = 2;
911 void clear_usb_backend_forced();
912 bool usb_backend_forced() const;
913 void set_usb_backend_forced(bool value);
914 private:
915 bool _internal_usb_backend_forced() const;
916 void _internal_set_usb_backend_forced(bool value);
917 public:
918
919 // bool mdns_backend_forced = 4;
920 void clear_mdns_backend_forced();
921 bool mdns_backend_forced() const;
922 void set_mdns_backend_forced(bool value);
923 private:
924 bool _internal_mdns_backend_forced() const;
925 void _internal_set_mdns_backend_forced(bool value);
926 public:
927
928 // @@protoc_insertion_point(class_scope:adb.proto.AdbServerStatus)
929 private:
930 class _Internal;
931
932 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
933 typedef void InternalArenaConstructable_;
934 typedef void DestructorSkippable_;
935 struct Impl_ {
936 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
937 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_;
938 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr executable_absolute_path_;
939 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_absolute_path_;
940 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr os_;
941 int usb_backend_;
942 int mdns_backend_;
943 bool usb_backend_forced_;
944 bool mdns_backend_forced_;
945 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
946 };
947 union { Impl_ _impl_; };
948 friend struct ::TableStruct_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto;
949 };
950 // ===================================================================
951
952
953 // ===================================================================
954
955 #ifdef __GNUC__
956 #pragma GCC diagnostic push
957 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
958 #endif // __GNUC__
959 // Device
960
961 // string serial = 1;
clear_serial()962 inline void Device::clear_serial() {
963 _impl_.serial_.ClearToEmpty();
964 }
serial()965 inline const std::string& Device::serial() const {
966 // @@protoc_insertion_point(field_get:adb.proto.Device.serial)
967 return _internal_serial();
968 }
969 template <typename ArgT0, typename... ArgT>
970 inline PROTOBUF_ALWAYS_INLINE
set_serial(ArgT0 && arg0,ArgT...args)971 void Device::set_serial(ArgT0&& arg0, ArgT... args) {
972
973 _impl_.serial_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
974 // @@protoc_insertion_point(field_set:adb.proto.Device.serial)
975 }
mutable_serial()976 inline std::string* Device::mutable_serial() {
977 std::string* _s = _internal_mutable_serial();
978 // @@protoc_insertion_point(field_mutable:adb.proto.Device.serial)
979 return _s;
980 }
_internal_serial()981 inline const std::string& Device::_internal_serial() const {
982 return _impl_.serial_.Get();
983 }
_internal_set_serial(const std::string & value)984 inline void Device::_internal_set_serial(const std::string& value) {
985
986 _impl_.serial_.Set(value, GetArenaForAllocation());
987 }
_internal_mutable_serial()988 inline std::string* Device::_internal_mutable_serial() {
989
990 return _impl_.serial_.Mutable(GetArenaForAllocation());
991 }
release_serial()992 inline std::string* Device::release_serial() {
993 // @@protoc_insertion_point(field_release:adb.proto.Device.serial)
994 return _impl_.serial_.Release();
995 }
set_allocated_serial(std::string * serial)996 inline void Device::set_allocated_serial(std::string* serial) {
997 _impl_.serial_.SetAllocated(serial, GetArenaForAllocation());
998 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
999 if (_impl_.serial_.IsDefault()) {
1000 _impl_.serial_.Set("", GetArenaForAllocation());
1001 }
1002 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1003 // @@protoc_insertion_point(field_set_allocated:adb.proto.Device.serial)
1004 }
1005
1006 // .adb.proto.ConnectionState state = 2;
clear_state()1007 inline void Device::clear_state() {
1008 _impl_.state_ = 0;
1009 }
_internal_state()1010 inline ::adb::proto::ConnectionState Device::_internal_state() const {
1011 return static_cast< ::adb::proto::ConnectionState >(_impl_.state_);
1012 }
state()1013 inline ::adb::proto::ConnectionState Device::state() const {
1014 // @@protoc_insertion_point(field_get:adb.proto.Device.state)
1015 return _internal_state();
1016 }
_internal_set_state(::adb::proto::ConnectionState value)1017 inline void Device::_internal_set_state(::adb::proto::ConnectionState value) {
1018
1019 _impl_.state_ = value;
1020 }
set_state(::adb::proto::ConnectionState value)1021 inline void Device::set_state(::adb::proto::ConnectionState value) {
1022 _internal_set_state(value);
1023 // @@protoc_insertion_point(field_set:adb.proto.Device.state)
1024 }
1025
1026 // string bus_address = 3;
clear_bus_address()1027 inline void Device::clear_bus_address() {
1028 _impl_.bus_address_.ClearToEmpty();
1029 }
bus_address()1030 inline const std::string& Device::bus_address() const {
1031 // @@protoc_insertion_point(field_get:adb.proto.Device.bus_address)
1032 return _internal_bus_address();
1033 }
1034 template <typename ArgT0, typename... ArgT>
1035 inline PROTOBUF_ALWAYS_INLINE
set_bus_address(ArgT0 && arg0,ArgT...args)1036 void Device::set_bus_address(ArgT0&& arg0, ArgT... args) {
1037
1038 _impl_.bus_address_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1039 // @@protoc_insertion_point(field_set:adb.proto.Device.bus_address)
1040 }
mutable_bus_address()1041 inline std::string* Device::mutable_bus_address() {
1042 std::string* _s = _internal_mutable_bus_address();
1043 // @@protoc_insertion_point(field_mutable:adb.proto.Device.bus_address)
1044 return _s;
1045 }
_internal_bus_address()1046 inline const std::string& Device::_internal_bus_address() const {
1047 return _impl_.bus_address_.Get();
1048 }
_internal_set_bus_address(const std::string & value)1049 inline void Device::_internal_set_bus_address(const std::string& value) {
1050
1051 _impl_.bus_address_.Set(value, GetArenaForAllocation());
1052 }
_internal_mutable_bus_address()1053 inline std::string* Device::_internal_mutable_bus_address() {
1054
1055 return _impl_.bus_address_.Mutable(GetArenaForAllocation());
1056 }
release_bus_address()1057 inline std::string* Device::release_bus_address() {
1058 // @@protoc_insertion_point(field_release:adb.proto.Device.bus_address)
1059 return _impl_.bus_address_.Release();
1060 }
set_allocated_bus_address(std::string * bus_address)1061 inline void Device::set_allocated_bus_address(std::string* bus_address) {
1062 _impl_.bus_address_.SetAllocated(bus_address, GetArenaForAllocation());
1063 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1064 if (_impl_.bus_address_.IsDefault()) {
1065 _impl_.bus_address_.Set("", GetArenaForAllocation());
1066 }
1067 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1068 // @@protoc_insertion_point(field_set_allocated:adb.proto.Device.bus_address)
1069 }
1070
1071 // string product = 4;
clear_product()1072 inline void Device::clear_product() {
1073 _impl_.product_.ClearToEmpty();
1074 }
product()1075 inline const std::string& Device::product() const {
1076 // @@protoc_insertion_point(field_get:adb.proto.Device.product)
1077 return _internal_product();
1078 }
1079 template <typename ArgT0, typename... ArgT>
1080 inline PROTOBUF_ALWAYS_INLINE
set_product(ArgT0 && arg0,ArgT...args)1081 void Device::set_product(ArgT0&& arg0, ArgT... args) {
1082
1083 _impl_.product_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1084 // @@protoc_insertion_point(field_set:adb.proto.Device.product)
1085 }
mutable_product()1086 inline std::string* Device::mutable_product() {
1087 std::string* _s = _internal_mutable_product();
1088 // @@protoc_insertion_point(field_mutable:adb.proto.Device.product)
1089 return _s;
1090 }
_internal_product()1091 inline const std::string& Device::_internal_product() const {
1092 return _impl_.product_.Get();
1093 }
_internal_set_product(const std::string & value)1094 inline void Device::_internal_set_product(const std::string& value) {
1095
1096 _impl_.product_.Set(value, GetArenaForAllocation());
1097 }
_internal_mutable_product()1098 inline std::string* Device::_internal_mutable_product() {
1099
1100 return _impl_.product_.Mutable(GetArenaForAllocation());
1101 }
release_product()1102 inline std::string* Device::release_product() {
1103 // @@protoc_insertion_point(field_release:adb.proto.Device.product)
1104 return _impl_.product_.Release();
1105 }
set_allocated_product(std::string * product)1106 inline void Device::set_allocated_product(std::string* product) {
1107 _impl_.product_.SetAllocated(product, GetArenaForAllocation());
1108 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1109 if (_impl_.product_.IsDefault()) {
1110 _impl_.product_.Set("", GetArenaForAllocation());
1111 }
1112 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1113 // @@protoc_insertion_point(field_set_allocated:adb.proto.Device.product)
1114 }
1115
1116 // string model = 5;
clear_model()1117 inline void Device::clear_model() {
1118 _impl_.model_.ClearToEmpty();
1119 }
model()1120 inline const std::string& Device::model() const {
1121 // @@protoc_insertion_point(field_get:adb.proto.Device.model)
1122 return _internal_model();
1123 }
1124 template <typename ArgT0, typename... ArgT>
1125 inline PROTOBUF_ALWAYS_INLINE
set_model(ArgT0 && arg0,ArgT...args)1126 void Device::set_model(ArgT0&& arg0, ArgT... args) {
1127
1128 _impl_.model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1129 // @@protoc_insertion_point(field_set:adb.proto.Device.model)
1130 }
mutable_model()1131 inline std::string* Device::mutable_model() {
1132 std::string* _s = _internal_mutable_model();
1133 // @@protoc_insertion_point(field_mutable:adb.proto.Device.model)
1134 return _s;
1135 }
_internal_model()1136 inline const std::string& Device::_internal_model() const {
1137 return _impl_.model_.Get();
1138 }
_internal_set_model(const std::string & value)1139 inline void Device::_internal_set_model(const std::string& value) {
1140
1141 _impl_.model_.Set(value, GetArenaForAllocation());
1142 }
_internal_mutable_model()1143 inline std::string* Device::_internal_mutable_model() {
1144
1145 return _impl_.model_.Mutable(GetArenaForAllocation());
1146 }
release_model()1147 inline std::string* Device::release_model() {
1148 // @@protoc_insertion_point(field_release:adb.proto.Device.model)
1149 return _impl_.model_.Release();
1150 }
set_allocated_model(std::string * model)1151 inline void Device::set_allocated_model(std::string* model) {
1152 _impl_.model_.SetAllocated(model, GetArenaForAllocation());
1153 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1154 if (_impl_.model_.IsDefault()) {
1155 _impl_.model_.Set("", GetArenaForAllocation());
1156 }
1157 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1158 // @@protoc_insertion_point(field_set_allocated:adb.proto.Device.model)
1159 }
1160
1161 // string device = 6;
clear_device()1162 inline void Device::clear_device() {
1163 _impl_.device_.ClearToEmpty();
1164 }
device()1165 inline const std::string& Device::device() const {
1166 // @@protoc_insertion_point(field_get:adb.proto.Device.device)
1167 return _internal_device();
1168 }
1169 template <typename ArgT0, typename... ArgT>
1170 inline PROTOBUF_ALWAYS_INLINE
set_device(ArgT0 && arg0,ArgT...args)1171 void Device::set_device(ArgT0&& arg0, ArgT... args) {
1172
1173 _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1174 // @@protoc_insertion_point(field_set:adb.proto.Device.device)
1175 }
mutable_device()1176 inline std::string* Device::mutable_device() {
1177 std::string* _s = _internal_mutable_device();
1178 // @@protoc_insertion_point(field_mutable:adb.proto.Device.device)
1179 return _s;
1180 }
_internal_device()1181 inline const std::string& Device::_internal_device() const {
1182 return _impl_.device_.Get();
1183 }
_internal_set_device(const std::string & value)1184 inline void Device::_internal_set_device(const std::string& value) {
1185
1186 _impl_.device_.Set(value, GetArenaForAllocation());
1187 }
_internal_mutable_device()1188 inline std::string* Device::_internal_mutable_device() {
1189
1190 return _impl_.device_.Mutable(GetArenaForAllocation());
1191 }
release_device()1192 inline std::string* Device::release_device() {
1193 // @@protoc_insertion_point(field_release:adb.proto.Device.device)
1194 return _impl_.device_.Release();
1195 }
set_allocated_device(std::string * device)1196 inline void Device::set_allocated_device(std::string* device) {
1197 _impl_.device_.SetAllocated(device, GetArenaForAllocation());
1198 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1199 if (_impl_.device_.IsDefault()) {
1200 _impl_.device_.Set("", GetArenaForAllocation());
1201 }
1202 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1203 // @@protoc_insertion_point(field_set_allocated:adb.proto.Device.device)
1204 }
1205
1206 // .adb.proto.ConnectionType connection_type = 7;
clear_connection_type()1207 inline void Device::clear_connection_type() {
1208 _impl_.connection_type_ = 0;
1209 }
_internal_connection_type()1210 inline ::adb::proto::ConnectionType Device::_internal_connection_type() const {
1211 return static_cast< ::adb::proto::ConnectionType >(_impl_.connection_type_);
1212 }
connection_type()1213 inline ::adb::proto::ConnectionType Device::connection_type() const {
1214 // @@protoc_insertion_point(field_get:adb.proto.Device.connection_type)
1215 return _internal_connection_type();
1216 }
_internal_set_connection_type(::adb::proto::ConnectionType value)1217 inline void Device::_internal_set_connection_type(::adb::proto::ConnectionType value) {
1218
1219 _impl_.connection_type_ = value;
1220 }
set_connection_type(::adb::proto::ConnectionType value)1221 inline void Device::set_connection_type(::adb::proto::ConnectionType value) {
1222 _internal_set_connection_type(value);
1223 // @@protoc_insertion_point(field_set:adb.proto.Device.connection_type)
1224 }
1225
1226 // int64 negotiated_speed = 8;
clear_negotiated_speed()1227 inline void Device::clear_negotiated_speed() {
1228 _impl_.negotiated_speed_ = ::int64_t{0};
1229 }
_internal_negotiated_speed()1230 inline ::int64_t Device::_internal_negotiated_speed() const {
1231 return _impl_.negotiated_speed_;
1232 }
negotiated_speed()1233 inline ::int64_t Device::negotiated_speed() const {
1234 // @@protoc_insertion_point(field_get:adb.proto.Device.negotiated_speed)
1235 return _internal_negotiated_speed();
1236 }
_internal_set_negotiated_speed(::int64_t value)1237 inline void Device::_internal_set_negotiated_speed(::int64_t value) {
1238
1239 _impl_.negotiated_speed_ = value;
1240 }
set_negotiated_speed(::int64_t value)1241 inline void Device::set_negotiated_speed(::int64_t value) {
1242 _internal_set_negotiated_speed(value);
1243 // @@protoc_insertion_point(field_set:adb.proto.Device.negotiated_speed)
1244 }
1245
1246 // int64 max_speed = 9;
clear_max_speed()1247 inline void Device::clear_max_speed() {
1248 _impl_.max_speed_ = ::int64_t{0};
1249 }
_internal_max_speed()1250 inline ::int64_t Device::_internal_max_speed() const {
1251 return _impl_.max_speed_;
1252 }
max_speed()1253 inline ::int64_t Device::max_speed() const {
1254 // @@protoc_insertion_point(field_get:adb.proto.Device.max_speed)
1255 return _internal_max_speed();
1256 }
_internal_set_max_speed(::int64_t value)1257 inline void Device::_internal_set_max_speed(::int64_t value) {
1258
1259 _impl_.max_speed_ = value;
1260 }
set_max_speed(::int64_t value)1261 inline void Device::set_max_speed(::int64_t value) {
1262 _internal_set_max_speed(value);
1263 // @@protoc_insertion_point(field_set:adb.proto.Device.max_speed)
1264 }
1265
1266 // int64 transport_id = 10;
clear_transport_id()1267 inline void Device::clear_transport_id() {
1268 _impl_.transport_id_ = ::int64_t{0};
1269 }
_internal_transport_id()1270 inline ::int64_t Device::_internal_transport_id() const {
1271 return _impl_.transport_id_;
1272 }
transport_id()1273 inline ::int64_t Device::transport_id() const {
1274 // @@protoc_insertion_point(field_get:adb.proto.Device.transport_id)
1275 return _internal_transport_id();
1276 }
_internal_set_transport_id(::int64_t value)1277 inline void Device::_internal_set_transport_id(::int64_t value) {
1278
1279 _impl_.transport_id_ = value;
1280 }
set_transport_id(::int64_t value)1281 inline void Device::set_transport_id(::int64_t value) {
1282 _internal_set_transport_id(value);
1283 // @@protoc_insertion_point(field_set:adb.proto.Device.transport_id)
1284 }
1285
1286 // -------------------------------------------------------------------
1287
1288 // Devices
1289
1290 // repeated .adb.proto.Device device = 1;
_internal_device_size()1291 inline int Devices::_internal_device_size() const {
1292 return _impl_.device_.size();
1293 }
device_size()1294 inline int Devices::device_size() const {
1295 return _internal_device_size();
1296 }
clear_device()1297 inline void Devices::clear_device() {
1298 _impl_.device_.Clear();
1299 }
mutable_device(int index)1300 inline ::adb::proto::Device* Devices::mutable_device(int index) {
1301 // @@protoc_insertion_point(field_mutable:adb.proto.Devices.device)
1302 return _impl_.device_.Mutable(index);
1303 }
1304 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::adb::proto::Device >*
mutable_device()1305 Devices::mutable_device() {
1306 // @@protoc_insertion_point(field_mutable_list:adb.proto.Devices.device)
1307 return &_impl_.device_;
1308 }
_internal_device(int index)1309 inline const ::adb::proto::Device& Devices::_internal_device(int index) const {
1310 return _impl_.device_.Get(index);
1311 }
device(int index)1312 inline const ::adb::proto::Device& Devices::device(int index) const {
1313 // @@protoc_insertion_point(field_get:adb.proto.Devices.device)
1314 return _internal_device(index);
1315 }
_internal_add_device()1316 inline ::adb::proto::Device* Devices::_internal_add_device() {
1317 return _impl_.device_.Add();
1318 }
add_device()1319 inline ::adb::proto::Device* Devices::add_device() {
1320 ::adb::proto::Device* _add = _internal_add_device();
1321 // @@protoc_insertion_point(field_add:adb.proto.Devices.device)
1322 return _add;
1323 }
1324 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::adb::proto::Device >&
device()1325 Devices::device() const {
1326 // @@protoc_insertion_point(field_list:adb.proto.Devices.device)
1327 return _impl_.device_;
1328 }
1329
1330 // -------------------------------------------------------------------
1331
1332 // AdbServerStatus
1333
1334 // .adb.proto.AdbServerStatus.UsbBackend usb_backend = 1;
clear_usb_backend()1335 inline void AdbServerStatus::clear_usb_backend() {
1336 _impl_.usb_backend_ = 0;
1337 }
_internal_usb_backend()1338 inline ::adb::proto::AdbServerStatus_UsbBackend AdbServerStatus::_internal_usb_backend() const {
1339 return static_cast< ::adb::proto::AdbServerStatus_UsbBackend >(_impl_.usb_backend_);
1340 }
usb_backend()1341 inline ::adb::proto::AdbServerStatus_UsbBackend AdbServerStatus::usb_backend() const {
1342 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.usb_backend)
1343 return _internal_usb_backend();
1344 }
_internal_set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value)1345 inline void AdbServerStatus::_internal_set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value) {
1346
1347 _impl_.usb_backend_ = value;
1348 }
set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value)1349 inline void AdbServerStatus::set_usb_backend(::adb::proto::AdbServerStatus_UsbBackend value) {
1350 _internal_set_usb_backend(value);
1351 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.usb_backend)
1352 }
1353
1354 // bool usb_backend_forced = 2;
clear_usb_backend_forced()1355 inline void AdbServerStatus::clear_usb_backend_forced() {
1356 _impl_.usb_backend_forced_ = false;
1357 }
_internal_usb_backend_forced()1358 inline bool AdbServerStatus::_internal_usb_backend_forced() const {
1359 return _impl_.usb_backend_forced_;
1360 }
usb_backend_forced()1361 inline bool AdbServerStatus::usb_backend_forced() const {
1362 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.usb_backend_forced)
1363 return _internal_usb_backend_forced();
1364 }
_internal_set_usb_backend_forced(bool value)1365 inline void AdbServerStatus::_internal_set_usb_backend_forced(bool value) {
1366
1367 _impl_.usb_backend_forced_ = value;
1368 }
set_usb_backend_forced(bool value)1369 inline void AdbServerStatus::set_usb_backend_forced(bool value) {
1370 _internal_set_usb_backend_forced(value);
1371 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.usb_backend_forced)
1372 }
1373
1374 // .adb.proto.AdbServerStatus.MdnsBackend mdns_backend = 3;
clear_mdns_backend()1375 inline void AdbServerStatus::clear_mdns_backend() {
1376 _impl_.mdns_backend_ = 0;
1377 }
_internal_mdns_backend()1378 inline ::adb::proto::AdbServerStatus_MdnsBackend AdbServerStatus::_internal_mdns_backend() const {
1379 return static_cast< ::adb::proto::AdbServerStatus_MdnsBackend >(_impl_.mdns_backend_);
1380 }
mdns_backend()1381 inline ::adb::proto::AdbServerStatus_MdnsBackend AdbServerStatus::mdns_backend() const {
1382 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.mdns_backend)
1383 return _internal_mdns_backend();
1384 }
_internal_set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value)1385 inline void AdbServerStatus::_internal_set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value) {
1386
1387 _impl_.mdns_backend_ = value;
1388 }
set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value)1389 inline void AdbServerStatus::set_mdns_backend(::adb::proto::AdbServerStatus_MdnsBackend value) {
1390 _internal_set_mdns_backend(value);
1391 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.mdns_backend)
1392 }
1393
1394 // bool mdns_backend_forced = 4;
clear_mdns_backend_forced()1395 inline void AdbServerStatus::clear_mdns_backend_forced() {
1396 _impl_.mdns_backend_forced_ = false;
1397 }
_internal_mdns_backend_forced()1398 inline bool AdbServerStatus::_internal_mdns_backend_forced() const {
1399 return _impl_.mdns_backend_forced_;
1400 }
mdns_backend_forced()1401 inline bool AdbServerStatus::mdns_backend_forced() const {
1402 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.mdns_backend_forced)
1403 return _internal_mdns_backend_forced();
1404 }
_internal_set_mdns_backend_forced(bool value)1405 inline void AdbServerStatus::_internal_set_mdns_backend_forced(bool value) {
1406
1407 _impl_.mdns_backend_forced_ = value;
1408 }
set_mdns_backend_forced(bool value)1409 inline void AdbServerStatus::set_mdns_backend_forced(bool value) {
1410 _internal_set_mdns_backend_forced(value);
1411 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.mdns_backend_forced)
1412 }
1413
1414 // string version = 5;
clear_version()1415 inline void AdbServerStatus::clear_version() {
1416 _impl_.version_.ClearToEmpty();
1417 }
version()1418 inline const std::string& AdbServerStatus::version() const {
1419 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.version)
1420 return _internal_version();
1421 }
1422 template <typename ArgT0, typename... ArgT>
1423 inline PROTOBUF_ALWAYS_INLINE
set_version(ArgT0 && arg0,ArgT...args)1424 void AdbServerStatus::set_version(ArgT0&& arg0, ArgT... args) {
1425
1426 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1427 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.version)
1428 }
mutable_version()1429 inline std::string* AdbServerStatus::mutable_version() {
1430 std::string* _s = _internal_mutable_version();
1431 // @@protoc_insertion_point(field_mutable:adb.proto.AdbServerStatus.version)
1432 return _s;
1433 }
_internal_version()1434 inline const std::string& AdbServerStatus::_internal_version() const {
1435 return _impl_.version_.Get();
1436 }
_internal_set_version(const std::string & value)1437 inline void AdbServerStatus::_internal_set_version(const std::string& value) {
1438
1439 _impl_.version_.Set(value, GetArenaForAllocation());
1440 }
_internal_mutable_version()1441 inline std::string* AdbServerStatus::_internal_mutable_version() {
1442
1443 return _impl_.version_.Mutable(GetArenaForAllocation());
1444 }
release_version()1445 inline std::string* AdbServerStatus::release_version() {
1446 // @@protoc_insertion_point(field_release:adb.proto.AdbServerStatus.version)
1447 return _impl_.version_.Release();
1448 }
set_allocated_version(std::string * version)1449 inline void AdbServerStatus::set_allocated_version(std::string* version) {
1450 _impl_.version_.SetAllocated(version, GetArenaForAllocation());
1451 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1452 if (_impl_.version_.IsDefault()) {
1453 _impl_.version_.Set("", GetArenaForAllocation());
1454 }
1455 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1456 // @@protoc_insertion_point(field_set_allocated:adb.proto.AdbServerStatus.version)
1457 }
1458
1459 // string build = 6;
clear_build()1460 inline void AdbServerStatus::clear_build() {
1461 _impl_.build_.ClearToEmpty();
1462 }
build()1463 inline const std::string& AdbServerStatus::build() const {
1464 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.build)
1465 return _internal_build();
1466 }
1467 template <typename ArgT0, typename... ArgT>
1468 inline PROTOBUF_ALWAYS_INLINE
set_build(ArgT0 && arg0,ArgT...args)1469 void AdbServerStatus::set_build(ArgT0&& arg0, ArgT... args) {
1470
1471 _impl_.build_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1472 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.build)
1473 }
mutable_build()1474 inline std::string* AdbServerStatus::mutable_build() {
1475 std::string* _s = _internal_mutable_build();
1476 // @@protoc_insertion_point(field_mutable:adb.proto.AdbServerStatus.build)
1477 return _s;
1478 }
_internal_build()1479 inline const std::string& AdbServerStatus::_internal_build() const {
1480 return _impl_.build_.Get();
1481 }
_internal_set_build(const std::string & value)1482 inline void AdbServerStatus::_internal_set_build(const std::string& value) {
1483
1484 _impl_.build_.Set(value, GetArenaForAllocation());
1485 }
_internal_mutable_build()1486 inline std::string* AdbServerStatus::_internal_mutable_build() {
1487
1488 return _impl_.build_.Mutable(GetArenaForAllocation());
1489 }
release_build()1490 inline std::string* AdbServerStatus::release_build() {
1491 // @@protoc_insertion_point(field_release:adb.proto.AdbServerStatus.build)
1492 return _impl_.build_.Release();
1493 }
set_allocated_build(std::string * build)1494 inline void AdbServerStatus::set_allocated_build(std::string* build) {
1495 _impl_.build_.SetAllocated(build, GetArenaForAllocation());
1496 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1497 if (_impl_.build_.IsDefault()) {
1498 _impl_.build_.Set("", GetArenaForAllocation());
1499 }
1500 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1501 // @@protoc_insertion_point(field_set_allocated:adb.proto.AdbServerStatus.build)
1502 }
1503
1504 // string executable_absolute_path = 7;
clear_executable_absolute_path()1505 inline void AdbServerStatus::clear_executable_absolute_path() {
1506 _impl_.executable_absolute_path_.ClearToEmpty();
1507 }
executable_absolute_path()1508 inline const std::string& AdbServerStatus::executable_absolute_path() const {
1509 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.executable_absolute_path)
1510 return _internal_executable_absolute_path();
1511 }
1512 template <typename ArgT0, typename... ArgT>
1513 inline PROTOBUF_ALWAYS_INLINE
set_executable_absolute_path(ArgT0 && arg0,ArgT...args)1514 void AdbServerStatus::set_executable_absolute_path(ArgT0&& arg0, ArgT... args) {
1515
1516 _impl_.executable_absolute_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1517 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.executable_absolute_path)
1518 }
mutable_executable_absolute_path()1519 inline std::string* AdbServerStatus::mutable_executable_absolute_path() {
1520 std::string* _s = _internal_mutable_executable_absolute_path();
1521 // @@protoc_insertion_point(field_mutable:adb.proto.AdbServerStatus.executable_absolute_path)
1522 return _s;
1523 }
_internal_executable_absolute_path()1524 inline const std::string& AdbServerStatus::_internal_executable_absolute_path() const {
1525 return _impl_.executable_absolute_path_.Get();
1526 }
_internal_set_executable_absolute_path(const std::string & value)1527 inline void AdbServerStatus::_internal_set_executable_absolute_path(const std::string& value) {
1528
1529 _impl_.executable_absolute_path_.Set(value, GetArenaForAllocation());
1530 }
_internal_mutable_executable_absolute_path()1531 inline std::string* AdbServerStatus::_internal_mutable_executable_absolute_path() {
1532
1533 return _impl_.executable_absolute_path_.Mutable(GetArenaForAllocation());
1534 }
release_executable_absolute_path()1535 inline std::string* AdbServerStatus::release_executable_absolute_path() {
1536 // @@protoc_insertion_point(field_release:adb.proto.AdbServerStatus.executable_absolute_path)
1537 return _impl_.executable_absolute_path_.Release();
1538 }
set_allocated_executable_absolute_path(std::string * executable_absolute_path)1539 inline void AdbServerStatus::set_allocated_executable_absolute_path(std::string* executable_absolute_path) {
1540 _impl_.executable_absolute_path_.SetAllocated(executable_absolute_path, GetArenaForAllocation());
1541 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1542 if (_impl_.executable_absolute_path_.IsDefault()) {
1543 _impl_.executable_absolute_path_.Set("", GetArenaForAllocation());
1544 }
1545 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1546 // @@protoc_insertion_point(field_set_allocated:adb.proto.AdbServerStatus.executable_absolute_path)
1547 }
1548
1549 // string log_absolute_path = 8;
clear_log_absolute_path()1550 inline void AdbServerStatus::clear_log_absolute_path() {
1551 _impl_.log_absolute_path_.ClearToEmpty();
1552 }
log_absolute_path()1553 inline const std::string& AdbServerStatus::log_absolute_path() const {
1554 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.log_absolute_path)
1555 return _internal_log_absolute_path();
1556 }
1557 template <typename ArgT0, typename... ArgT>
1558 inline PROTOBUF_ALWAYS_INLINE
set_log_absolute_path(ArgT0 && arg0,ArgT...args)1559 void AdbServerStatus::set_log_absolute_path(ArgT0&& arg0, ArgT... args) {
1560
1561 _impl_.log_absolute_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1562 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.log_absolute_path)
1563 }
mutable_log_absolute_path()1564 inline std::string* AdbServerStatus::mutable_log_absolute_path() {
1565 std::string* _s = _internal_mutable_log_absolute_path();
1566 // @@protoc_insertion_point(field_mutable:adb.proto.AdbServerStatus.log_absolute_path)
1567 return _s;
1568 }
_internal_log_absolute_path()1569 inline const std::string& AdbServerStatus::_internal_log_absolute_path() const {
1570 return _impl_.log_absolute_path_.Get();
1571 }
_internal_set_log_absolute_path(const std::string & value)1572 inline void AdbServerStatus::_internal_set_log_absolute_path(const std::string& value) {
1573
1574 _impl_.log_absolute_path_.Set(value, GetArenaForAllocation());
1575 }
_internal_mutable_log_absolute_path()1576 inline std::string* AdbServerStatus::_internal_mutable_log_absolute_path() {
1577
1578 return _impl_.log_absolute_path_.Mutable(GetArenaForAllocation());
1579 }
release_log_absolute_path()1580 inline std::string* AdbServerStatus::release_log_absolute_path() {
1581 // @@protoc_insertion_point(field_release:adb.proto.AdbServerStatus.log_absolute_path)
1582 return _impl_.log_absolute_path_.Release();
1583 }
set_allocated_log_absolute_path(std::string * log_absolute_path)1584 inline void AdbServerStatus::set_allocated_log_absolute_path(std::string* log_absolute_path) {
1585 _impl_.log_absolute_path_.SetAllocated(log_absolute_path, GetArenaForAllocation());
1586 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1587 if (_impl_.log_absolute_path_.IsDefault()) {
1588 _impl_.log_absolute_path_.Set("", GetArenaForAllocation());
1589 }
1590 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1591 // @@protoc_insertion_point(field_set_allocated:adb.proto.AdbServerStatus.log_absolute_path)
1592 }
1593
1594 // string os = 9;
clear_os()1595 inline void AdbServerStatus::clear_os() {
1596 _impl_.os_.ClearToEmpty();
1597 }
os()1598 inline const std::string& AdbServerStatus::os() const {
1599 // @@protoc_insertion_point(field_get:adb.proto.AdbServerStatus.os)
1600 return _internal_os();
1601 }
1602 template <typename ArgT0, typename... ArgT>
1603 inline PROTOBUF_ALWAYS_INLINE
set_os(ArgT0 && arg0,ArgT...args)1604 void AdbServerStatus::set_os(ArgT0&& arg0, ArgT... args) {
1605
1606 _impl_.os_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1607 // @@protoc_insertion_point(field_set:adb.proto.AdbServerStatus.os)
1608 }
mutable_os()1609 inline std::string* AdbServerStatus::mutable_os() {
1610 std::string* _s = _internal_mutable_os();
1611 // @@protoc_insertion_point(field_mutable:adb.proto.AdbServerStatus.os)
1612 return _s;
1613 }
_internal_os()1614 inline const std::string& AdbServerStatus::_internal_os() const {
1615 return _impl_.os_.Get();
1616 }
_internal_set_os(const std::string & value)1617 inline void AdbServerStatus::_internal_set_os(const std::string& value) {
1618
1619 _impl_.os_.Set(value, GetArenaForAllocation());
1620 }
_internal_mutable_os()1621 inline std::string* AdbServerStatus::_internal_mutable_os() {
1622
1623 return _impl_.os_.Mutable(GetArenaForAllocation());
1624 }
release_os()1625 inline std::string* AdbServerStatus::release_os() {
1626 // @@protoc_insertion_point(field_release:adb.proto.AdbServerStatus.os)
1627 return _impl_.os_.Release();
1628 }
set_allocated_os(std::string * os)1629 inline void AdbServerStatus::set_allocated_os(std::string* os) {
1630 _impl_.os_.SetAllocated(os, GetArenaForAllocation());
1631 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1632 if (_impl_.os_.IsDefault()) {
1633 _impl_.os_.Set("", GetArenaForAllocation());
1634 }
1635 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1636 // @@protoc_insertion_point(field_set_allocated:adb.proto.AdbServerStatus.os)
1637 }
1638
1639 #ifdef __GNUC__
1640 #pragma GCC diagnostic pop
1641 #endif // __GNUC__
1642 // -------------------------------------------------------------------
1643
1644 // -------------------------------------------------------------------
1645
1646
1647 // @@protoc_insertion_point(namespace_scope)
1648
1649 } // namespace proto
1650 } // namespace adb
1651
1652 PROTOBUF_NAMESPACE_OPEN
1653
1654 template <> struct is_proto_enum< ::adb::proto::AdbServerStatus_UsbBackend> : ::std::true_type {};
1655 template <>
1656 inline const EnumDescriptor* GetEnumDescriptor< ::adb::proto::AdbServerStatus_UsbBackend>() {
1657 return ::adb::proto::AdbServerStatus_UsbBackend_descriptor();
1658 }
1659 template <> struct is_proto_enum< ::adb::proto::AdbServerStatus_MdnsBackend> : ::std::true_type {};
1660 template <>
1661 inline const EnumDescriptor* GetEnumDescriptor< ::adb::proto::AdbServerStatus_MdnsBackend>() {
1662 return ::adb::proto::AdbServerStatus_MdnsBackend_descriptor();
1663 }
1664 template <> struct is_proto_enum< ::adb::proto::ConnectionState> : ::std::true_type {};
1665 template <>
1666 inline const EnumDescriptor* GetEnumDescriptor< ::adb::proto::ConnectionState>() {
1667 return ::adb::proto::ConnectionState_descriptor();
1668 }
1669 template <> struct is_proto_enum< ::adb::proto::ConnectionType> : ::std::true_type {};
1670 template <>
1671 inline const EnumDescriptor* GetEnumDescriptor< ::adb::proto::ConnectionType>() {
1672 return ::adb::proto::ConnectionType_descriptor();
1673 }
1674
1675 PROTOBUF_NAMESPACE_CLOSE
1676
1677 // @@protoc_insertion_point(global_scope)
1678
1679 #include <google/protobuf/port_undef.inc>
1680 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_packages_2fmodules_2fadb_2fproto_2fadb_5fhost_2eproto
1681