1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: printer_event.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_printer_5fevent_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_printer_5fevent_2eproto
6
7 #include <limits>
8 #include <string>
9
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3021000
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 3021012 < 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_util.h>
27 #include <google/protobuf/metadata_lite.h>
28 #include <google/protobuf/message_lite.h>
29 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
30 #include <google/protobuf/extension_set.h> // IWYU pragma: export
31 #include <google/protobuf/generated_enum_util.h>
32 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_printer_5fevent_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 } // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_printer_5fevent_2eproto {
43 static const uint32_t offsets[];
44 };
45 namespace metrics {
46 class PrinterEventProto;
47 struct PrinterEventProtoDefaultTypeInternal;
48 extern PrinterEventProtoDefaultTypeInternal _PrinterEventProto_default_instance_;
49 } // namespace metrics
50 PROTOBUF_NAMESPACE_OPEN
51 template<> ::metrics::PrinterEventProto* Arena::CreateMaybeMessage<::metrics::PrinterEventProto>(Arena*);
52 PROTOBUF_NAMESPACE_CLOSE
53 namespace metrics {
54
55 enum PrinterEventProto_EventType : int {
56 PrinterEventProto_EventType_UNKNOWN = 0,
57 PrinterEventProto_EventType_SETUP_AUTOMATIC = 1,
58 PrinterEventProto_EventType_SETUP_MANUAL = 2,
59 PrinterEventProto_EventType_SETUP_ABANDONED = 3,
60 PrinterEventProto_EventType_PRINTER_DELETED = 4
61 };
62 bool PrinterEventProto_EventType_IsValid(int value);
63 constexpr PrinterEventProto_EventType PrinterEventProto_EventType_EventType_MIN = PrinterEventProto_EventType_UNKNOWN;
64 constexpr PrinterEventProto_EventType PrinterEventProto_EventType_EventType_MAX = PrinterEventProto_EventType_PRINTER_DELETED;
65 constexpr int PrinterEventProto_EventType_EventType_ARRAYSIZE = PrinterEventProto_EventType_EventType_MAX + 1;
66
67 const std::string& PrinterEventProto_EventType_Name(PrinterEventProto_EventType value);
68 template<typename T>
PrinterEventProto_EventType_Name(T enum_t_value)69 inline const std::string& PrinterEventProto_EventType_Name(T enum_t_value) {
70 static_assert(::std::is_same<T, PrinterEventProto_EventType>::value ||
71 ::std::is_integral<T>::value,
72 "Incorrect type passed to function PrinterEventProto_EventType_Name.");
73 return PrinterEventProto_EventType_Name(static_cast<PrinterEventProto_EventType>(enum_t_value));
74 }
75 bool PrinterEventProto_EventType_Parse(
76 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PrinterEventProto_EventType* value);
77 // ===================================================================
78
79 class PrinterEventProto final :
80 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:metrics.PrinterEventProto) */ {
81 public:
PrinterEventProto()82 inline PrinterEventProto() : PrinterEventProto(nullptr) {}
83 ~PrinterEventProto() override;
84 explicit PROTOBUF_CONSTEXPR PrinterEventProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
85
86 PrinterEventProto(const PrinterEventProto& from);
PrinterEventProto(PrinterEventProto && from)87 PrinterEventProto(PrinterEventProto&& from) noexcept
88 : PrinterEventProto() {
89 *this = ::std::move(from);
90 }
91
92 inline PrinterEventProto& operator=(const PrinterEventProto& from) {
93 CopyFrom(from);
94 return *this;
95 }
96 inline PrinterEventProto& operator=(PrinterEventProto&& from) noexcept {
97 if (this == &from) return *this;
98 if (GetOwningArena() == from.GetOwningArena()
99 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
100 && GetOwningArena() != nullptr
101 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
102 ) {
103 InternalSwap(&from);
104 } else {
105 CopyFrom(from);
106 }
107 return *this;
108 }
109
unknown_fields()110 inline const std::string& unknown_fields() const {
111 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
112 }
mutable_unknown_fields()113 inline std::string* mutable_unknown_fields() {
114 return _internal_metadata_.mutable_unknown_fields<std::string>();
115 }
116
default_instance()117 static const PrinterEventProto& default_instance() {
118 return *internal_default_instance();
119 }
internal_default_instance()120 static inline const PrinterEventProto* internal_default_instance() {
121 return reinterpret_cast<const PrinterEventProto*>(
122 &_PrinterEventProto_default_instance_);
123 }
124 static constexpr int kIndexInFileMessages =
125 0;
126
swap(PrinterEventProto & a,PrinterEventProto & b)127 friend void swap(PrinterEventProto& a, PrinterEventProto& b) {
128 a.Swap(&b);
129 }
Swap(PrinterEventProto * other)130 PROTOBUF_NOINLINE void Swap(PrinterEventProto* other) {
131 if (other == this) return;
132 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
133 if (GetOwningArena() != nullptr &&
134 GetOwningArena() == other->GetOwningArena()) {
135 #else // PROTOBUF_FORCE_COPY_IN_SWAP
136 if (GetOwningArena() == other->GetOwningArena()) {
137 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
138 InternalSwap(other);
139 } else {
140 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
141 }
142 }
143 void UnsafeArenaSwap(PrinterEventProto* other) {
144 if (other == this) return;
145 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
146 InternalSwap(other);
147 }
148
149 // implements Message ----------------------------------------------
150
151 PrinterEventProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
152 return CreateMaybeMessage<PrinterEventProto>(arena);
153 }
154 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
155 void CopyFrom(const PrinterEventProto& from);
156 void MergeFrom(const PrinterEventProto& from);
157 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
158 bool IsInitialized() const final;
159
160 size_t ByteSizeLong() const final;
161 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
162 uint8_t* _InternalSerialize(
163 uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
164 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
165
166 private:
167 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
168 void SharedDtor();
169 void SetCachedSize(int size) const;
170 void InternalSwap(PrinterEventProto* other);
171
172 private:
173 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
174 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
175 return "metrics.PrinterEventProto";
176 }
177 protected:
178 explicit PrinterEventProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
179 bool is_message_owned = false);
180 public:
181
182 std::string GetTypeName() const final;
183
184 // nested types ----------------------------------------------------
185
186 typedef PrinterEventProto_EventType EventType;
187 static constexpr EventType UNKNOWN =
188 PrinterEventProto_EventType_UNKNOWN;
189 static constexpr EventType SETUP_AUTOMATIC =
190 PrinterEventProto_EventType_SETUP_AUTOMATIC;
191 static constexpr EventType SETUP_MANUAL =
192 PrinterEventProto_EventType_SETUP_MANUAL;
193 static constexpr EventType SETUP_ABANDONED =
194 PrinterEventProto_EventType_SETUP_ABANDONED;
195 static constexpr EventType PRINTER_DELETED =
196 PrinterEventProto_EventType_PRINTER_DELETED;
197 static inline bool EventType_IsValid(int value) {
198 return PrinterEventProto_EventType_IsValid(value);
199 }
200 static constexpr EventType EventType_MIN =
201 PrinterEventProto_EventType_EventType_MIN;
202 static constexpr EventType EventType_MAX =
203 PrinterEventProto_EventType_EventType_MAX;
204 static constexpr int EventType_ARRAYSIZE =
205 PrinterEventProto_EventType_EventType_ARRAYSIZE;
206 template<typename T>
207 static inline const std::string& EventType_Name(T enum_t_value) {
208 static_assert(::std::is_same<T, EventType>::value ||
209 ::std::is_integral<T>::value,
210 "Incorrect type passed to function EventType_Name.");
211 return PrinterEventProto_EventType_Name(enum_t_value);
212 }
213 static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
214 EventType* value) {
215 return PrinterEventProto_EventType_Parse(name, value);
216 }
217
218 // accessors -------------------------------------------------------
219
220 enum : int {
221 kUsbPrinterManufacturerFieldNumber = 1,
222 kUsbPrinterModelFieldNumber = 2,
223 kIppMakeAndModelFieldNumber = 5,
224 kPpdIdentifierFieldNumber = 7,
225 kUsbVendorIdFieldNumber = 3,
226 kUsbModelIdFieldNumber = 4,
227 kUserPpdFieldNumber = 6,
228 kEventTypeFieldNumber = 8,
229 };
230 // optional string usb_printer_manufacturer = 1;
231 bool has_usb_printer_manufacturer() const;
232 private:
233 bool _internal_has_usb_printer_manufacturer() const;
234 public:
235 void clear_usb_printer_manufacturer();
236 const std::string& usb_printer_manufacturer() const;
237 template <typename ArgT0 = const std::string&, typename... ArgT>
238 void set_usb_printer_manufacturer(ArgT0&& arg0, ArgT... args);
239 std::string* mutable_usb_printer_manufacturer();
240 PROTOBUF_NODISCARD std::string* release_usb_printer_manufacturer();
241 void set_allocated_usb_printer_manufacturer(std::string* usb_printer_manufacturer);
242 private:
243 const std::string& _internal_usb_printer_manufacturer() const;
244 inline PROTOBUF_ALWAYS_INLINE void _internal_set_usb_printer_manufacturer(const std::string& value);
245 std::string* _internal_mutable_usb_printer_manufacturer();
246 public:
247
248 // optional string usb_printer_model = 2;
249 bool has_usb_printer_model() const;
250 private:
251 bool _internal_has_usb_printer_model() const;
252 public:
253 void clear_usb_printer_model();
254 const std::string& usb_printer_model() const;
255 template <typename ArgT0 = const std::string&, typename... ArgT>
256 void set_usb_printer_model(ArgT0&& arg0, ArgT... args);
257 std::string* mutable_usb_printer_model();
258 PROTOBUF_NODISCARD std::string* release_usb_printer_model();
259 void set_allocated_usb_printer_model(std::string* usb_printer_model);
260 private:
261 const std::string& _internal_usb_printer_model() const;
262 inline PROTOBUF_ALWAYS_INLINE void _internal_set_usb_printer_model(const std::string& value);
263 std::string* _internal_mutable_usb_printer_model();
264 public:
265
266 // optional string ipp_make_and_model = 5;
267 bool has_ipp_make_and_model() const;
268 private:
269 bool _internal_has_ipp_make_and_model() const;
270 public:
271 void clear_ipp_make_and_model();
272 const std::string& ipp_make_and_model() const;
273 template <typename ArgT0 = const std::string&, typename... ArgT>
274 void set_ipp_make_and_model(ArgT0&& arg0, ArgT... args);
275 std::string* mutable_ipp_make_and_model();
276 PROTOBUF_NODISCARD std::string* release_ipp_make_and_model();
277 void set_allocated_ipp_make_and_model(std::string* ipp_make_and_model);
278 private:
279 const std::string& _internal_ipp_make_and_model() const;
280 inline PROTOBUF_ALWAYS_INLINE void _internal_set_ipp_make_and_model(const std::string& value);
281 std::string* _internal_mutable_ipp_make_and_model();
282 public:
283
284 // optional string ppd_identifier = 7;
285 bool has_ppd_identifier() const;
286 private:
287 bool _internal_has_ppd_identifier() const;
288 public:
289 void clear_ppd_identifier();
290 const std::string& ppd_identifier() const;
291 template <typename ArgT0 = const std::string&, typename... ArgT>
292 void set_ppd_identifier(ArgT0&& arg0, ArgT... args);
293 std::string* mutable_ppd_identifier();
294 PROTOBUF_NODISCARD std::string* release_ppd_identifier();
295 void set_allocated_ppd_identifier(std::string* ppd_identifier);
296 private:
297 const std::string& _internal_ppd_identifier() const;
298 inline PROTOBUF_ALWAYS_INLINE void _internal_set_ppd_identifier(const std::string& value);
299 std::string* _internal_mutable_ppd_identifier();
300 public:
301
302 // optional int32 usb_vendor_id = 3;
303 bool has_usb_vendor_id() const;
304 private:
305 bool _internal_has_usb_vendor_id() const;
306 public:
307 void clear_usb_vendor_id();
308 int32_t usb_vendor_id() const;
309 void set_usb_vendor_id(int32_t value);
310 private:
311 int32_t _internal_usb_vendor_id() const;
312 void _internal_set_usb_vendor_id(int32_t value);
313 public:
314
315 // optional int32 usb_model_id = 4;
316 bool has_usb_model_id() const;
317 private:
318 bool _internal_has_usb_model_id() const;
319 public:
320 void clear_usb_model_id();
321 int32_t usb_model_id() const;
322 void set_usb_model_id(int32_t value);
323 private:
324 int32_t _internal_usb_model_id() const;
325 void _internal_set_usb_model_id(int32_t value);
326 public:
327
328 // optional bool user_ppd = 6;
329 bool has_user_ppd() const;
330 private:
331 bool _internal_has_user_ppd() const;
332 public:
333 void clear_user_ppd();
334 bool user_ppd() const;
335 void set_user_ppd(bool value);
336 private:
337 bool _internal_user_ppd() const;
338 void _internal_set_user_ppd(bool value);
339 public:
340
341 // optional .metrics.PrinterEventProto.EventType event_type = 8;
342 bool has_event_type() const;
343 private:
344 bool _internal_has_event_type() const;
345 public:
346 void clear_event_type();
347 ::metrics::PrinterEventProto_EventType event_type() const;
348 void set_event_type(::metrics::PrinterEventProto_EventType value);
349 private:
350 ::metrics::PrinterEventProto_EventType _internal_event_type() const;
351 void _internal_set_event_type(::metrics::PrinterEventProto_EventType value);
352 public:
353
354 // @@protoc_insertion_point(class_scope:metrics.PrinterEventProto)
355 private:
356 class _Internal;
357
358 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
359 typedef void InternalArenaConstructable_;
360 typedef void DestructorSkippable_;
361 struct Impl_ {
362 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
363 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
364 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr usb_printer_manufacturer_;
365 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr usb_printer_model_;
366 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ipp_make_and_model_;
367 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ppd_identifier_;
368 int32_t usb_vendor_id_;
369 int32_t usb_model_id_;
370 bool user_ppd_;
371 int event_type_;
372 };
373 union { Impl_ _impl_; };
374 friend struct ::TableStruct_printer_5fevent_2eproto;
375 };
376 // ===================================================================
377
378
379 // ===================================================================
380
381 #ifdef __GNUC__
382 #pragma GCC diagnostic push
383 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
384 #endif // __GNUC__
385 // PrinterEventProto
386
387 // optional string usb_printer_manufacturer = 1;
_internal_has_usb_printer_manufacturer()388 inline bool PrinterEventProto::_internal_has_usb_printer_manufacturer() const {
389 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
390 return value;
391 }
has_usb_printer_manufacturer()392 inline bool PrinterEventProto::has_usb_printer_manufacturer() const {
393 return _internal_has_usb_printer_manufacturer();
394 }
clear_usb_printer_manufacturer()395 inline void PrinterEventProto::clear_usb_printer_manufacturer() {
396 _impl_.usb_printer_manufacturer_.ClearToEmpty();
397 _impl_._has_bits_[0] &= ~0x00000001u;
398 }
usb_printer_manufacturer()399 inline const std::string& PrinterEventProto::usb_printer_manufacturer() const {
400 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.usb_printer_manufacturer)
401 return _internal_usb_printer_manufacturer();
402 }
403 template <typename ArgT0, typename... ArgT>
404 inline PROTOBUF_ALWAYS_INLINE
set_usb_printer_manufacturer(ArgT0 && arg0,ArgT...args)405 void PrinterEventProto::set_usb_printer_manufacturer(ArgT0&& arg0, ArgT... args) {
406 _impl_._has_bits_[0] |= 0x00000001u;
407 _impl_.usb_printer_manufacturer_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
408 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.usb_printer_manufacturer)
409 }
mutable_usb_printer_manufacturer()410 inline std::string* PrinterEventProto::mutable_usb_printer_manufacturer() {
411 std::string* _s = _internal_mutable_usb_printer_manufacturer();
412 // @@protoc_insertion_point(field_mutable:metrics.PrinterEventProto.usb_printer_manufacturer)
413 return _s;
414 }
_internal_usb_printer_manufacturer()415 inline const std::string& PrinterEventProto::_internal_usb_printer_manufacturer() const {
416 return _impl_.usb_printer_manufacturer_.Get();
417 }
_internal_set_usb_printer_manufacturer(const std::string & value)418 inline void PrinterEventProto::_internal_set_usb_printer_manufacturer(const std::string& value) {
419 _impl_._has_bits_[0] |= 0x00000001u;
420 _impl_.usb_printer_manufacturer_.Set(value, GetArenaForAllocation());
421 }
_internal_mutable_usb_printer_manufacturer()422 inline std::string* PrinterEventProto::_internal_mutable_usb_printer_manufacturer() {
423 _impl_._has_bits_[0] |= 0x00000001u;
424 return _impl_.usb_printer_manufacturer_.Mutable(GetArenaForAllocation());
425 }
release_usb_printer_manufacturer()426 inline std::string* PrinterEventProto::release_usb_printer_manufacturer() {
427 // @@protoc_insertion_point(field_release:metrics.PrinterEventProto.usb_printer_manufacturer)
428 if (!_internal_has_usb_printer_manufacturer()) {
429 return nullptr;
430 }
431 _impl_._has_bits_[0] &= ~0x00000001u;
432 auto* p = _impl_.usb_printer_manufacturer_.Release();
433 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
434 if (_impl_.usb_printer_manufacturer_.IsDefault()) {
435 _impl_.usb_printer_manufacturer_.Set("", GetArenaForAllocation());
436 }
437 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
438 return p;
439 }
set_allocated_usb_printer_manufacturer(std::string * usb_printer_manufacturer)440 inline void PrinterEventProto::set_allocated_usb_printer_manufacturer(std::string* usb_printer_manufacturer) {
441 if (usb_printer_manufacturer != nullptr) {
442 _impl_._has_bits_[0] |= 0x00000001u;
443 } else {
444 _impl_._has_bits_[0] &= ~0x00000001u;
445 }
446 _impl_.usb_printer_manufacturer_.SetAllocated(usb_printer_manufacturer, GetArenaForAllocation());
447 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
448 if (_impl_.usb_printer_manufacturer_.IsDefault()) {
449 _impl_.usb_printer_manufacturer_.Set("", GetArenaForAllocation());
450 }
451 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
452 // @@protoc_insertion_point(field_set_allocated:metrics.PrinterEventProto.usb_printer_manufacturer)
453 }
454
455 // optional string usb_printer_model = 2;
_internal_has_usb_printer_model()456 inline bool PrinterEventProto::_internal_has_usb_printer_model() const {
457 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
458 return value;
459 }
has_usb_printer_model()460 inline bool PrinterEventProto::has_usb_printer_model() const {
461 return _internal_has_usb_printer_model();
462 }
clear_usb_printer_model()463 inline void PrinterEventProto::clear_usb_printer_model() {
464 _impl_.usb_printer_model_.ClearToEmpty();
465 _impl_._has_bits_[0] &= ~0x00000002u;
466 }
usb_printer_model()467 inline const std::string& PrinterEventProto::usb_printer_model() const {
468 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.usb_printer_model)
469 return _internal_usb_printer_model();
470 }
471 template <typename ArgT0, typename... ArgT>
472 inline PROTOBUF_ALWAYS_INLINE
set_usb_printer_model(ArgT0 && arg0,ArgT...args)473 void PrinterEventProto::set_usb_printer_model(ArgT0&& arg0, ArgT... args) {
474 _impl_._has_bits_[0] |= 0x00000002u;
475 _impl_.usb_printer_model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
476 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.usb_printer_model)
477 }
mutable_usb_printer_model()478 inline std::string* PrinterEventProto::mutable_usb_printer_model() {
479 std::string* _s = _internal_mutable_usb_printer_model();
480 // @@protoc_insertion_point(field_mutable:metrics.PrinterEventProto.usb_printer_model)
481 return _s;
482 }
_internal_usb_printer_model()483 inline const std::string& PrinterEventProto::_internal_usb_printer_model() const {
484 return _impl_.usb_printer_model_.Get();
485 }
_internal_set_usb_printer_model(const std::string & value)486 inline void PrinterEventProto::_internal_set_usb_printer_model(const std::string& value) {
487 _impl_._has_bits_[0] |= 0x00000002u;
488 _impl_.usb_printer_model_.Set(value, GetArenaForAllocation());
489 }
_internal_mutable_usb_printer_model()490 inline std::string* PrinterEventProto::_internal_mutable_usb_printer_model() {
491 _impl_._has_bits_[0] |= 0x00000002u;
492 return _impl_.usb_printer_model_.Mutable(GetArenaForAllocation());
493 }
release_usb_printer_model()494 inline std::string* PrinterEventProto::release_usb_printer_model() {
495 // @@protoc_insertion_point(field_release:metrics.PrinterEventProto.usb_printer_model)
496 if (!_internal_has_usb_printer_model()) {
497 return nullptr;
498 }
499 _impl_._has_bits_[0] &= ~0x00000002u;
500 auto* p = _impl_.usb_printer_model_.Release();
501 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
502 if (_impl_.usb_printer_model_.IsDefault()) {
503 _impl_.usb_printer_model_.Set("", GetArenaForAllocation());
504 }
505 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
506 return p;
507 }
set_allocated_usb_printer_model(std::string * usb_printer_model)508 inline void PrinterEventProto::set_allocated_usb_printer_model(std::string* usb_printer_model) {
509 if (usb_printer_model != nullptr) {
510 _impl_._has_bits_[0] |= 0x00000002u;
511 } else {
512 _impl_._has_bits_[0] &= ~0x00000002u;
513 }
514 _impl_.usb_printer_model_.SetAllocated(usb_printer_model, GetArenaForAllocation());
515 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
516 if (_impl_.usb_printer_model_.IsDefault()) {
517 _impl_.usb_printer_model_.Set("", GetArenaForAllocation());
518 }
519 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
520 // @@protoc_insertion_point(field_set_allocated:metrics.PrinterEventProto.usb_printer_model)
521 }
522
523 // optional int32 usb_vendor_id = 3;
_internal_has_usb_vendor_id()524 inline bool PrinterEventProto::_internal_has_usb_vendor_id() const {
525 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
526 return value;
527 }
has_usb_vendor_id()528 inline bool PrinterEventProto::has_usb_vendor_id() const {
529 return _internal_has_usb_vendor_id();
530 }
clear_usb_vendor_id()531 inline void PrinterEventProto::clear_usb_vendor_id() {
532 _impl_.usb_vendor_id_ = 0;
533 _impl_._has_bits_[0] &= ~0x00000010u;
534 }
_internal_usb_vendor_id()535 inline int32_t PrinterEventProto::_internal_usb_vendor_id() const {
536 return _impl_.usb_vendor_id_;
537 }
usb_vendor_id()538 inline int32_t PrinterEventProto::usb_vendor_id() const {
539 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.usb_vendor_id)
540 return _internal_usb_vendor_id();
541 }
_internal_set_usb_vendor_id(int32_t value)542 inline void PrinterEventProto::_internal_set_usb_vendor_id(int32_t value) {
543 _impl_._has_bits_[0] |= 0x00000010u;
544 _impl_.usb_vendor_id_ = value;
545 }
set_usb_vendor_id(int32_t value)546 inline void PrinterEventProto::set_usb_vendor_id(int32_t value) {
547 _internal_set_usb_vendor_id(value);
548 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.usb_vendor_id)
549 }
550
551 // optional int32 usb_model_id = 4;
_internal_has_usb_model_id()552 inline bool PrinterEventProto::_internal_has_usb_model_id() const {
553 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
554 return value;
555 }
has_usb_model_id()556 inline bool PrinterEventProto::has_usb_model_id() const {
557 return _internal_has_usb_model_id();
558 }
clear_usb_model_id()559 inline void PrinterEventProto::clear_usb_model_id() {
560 _impl_.usb_model_id_ = 0;
561 _impl_._has_bits_[0] &= ~0x00000020u;
562 }
_internal_usb_model_id()563 inline int32_t PrinterEventProto::_internal_usb_model_id() const {
564 return _impl_.usb_model_id_;
565 }
usb_model_id()566 inline int32_t PrinterEventProto::usb_model_id() const {
567 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.usb_model_id)
568 return _internal_usb_model_id();
569 }
_internal_set_usb_model_id(int32_t value)570 inline void PrinterEventProto::_internal_set_usb_model_id(int32_t value) {
571 _impl_._has_bits_[0] |= 0x00000020u;
572 _impl_.usb_model_id_ = value;
573 }
set_usb_model_id(int32_t value)574 inline void PrinterEventProto::set_usb_model_id(int32_t value) {
575 _internal_set_usb_model_id(value);
576 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.usb_model_id)
577 }
578
579 // optional string ipp_make_and_model = 5;
_internal_has_ipp_make_and_model()580 inline bool PrinterEventProto::_internal_has_ipp_make_and_model() const {
581 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
582 return value;
583 }
has_ipp_make_and_model()584 inline bool PrinterEventProto::has_ipp_make_and_model() const {
585 return _internal_has_ipp_make_and_model();
586 }
clear_ipp_make_and_model()587 inline void PrinterEventProto::clear_ipp_make_and_model() {
588 _impl_.ipp_make_and_model_.ClearToEmpty();
589 _impl_._has_bits_[0] &= ~0x00000004u;
590 }
ipp_make_and_model()591 inline const std::string& PrinterEventProto::ipp_make_and_model() const {
592 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.ipp_make_and_model)
593 return _internal_ipp_make_and_model();
594 }
595 template <typename ArgT0, typename... ArgT>
596 inline PROTOBUF_ALWAYS_INLINE
set_ipp_make_and_model(ArgT0 && arg0,ArgT...args)597 void PrinterEventProto::set_ipp_make_and_model(ArgT0&& arg0, ArgT... args) {
598 _impl_._has_bits_[0] |= 0x00000004u;
599 _impl_.ipp_make_and_model_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
600 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.ipp_make_and_model)
601 }
mutable_ipp_make_and_model()602 inline std::string* PrinterEventProto::mutable_ipp_make_and_model() {
603 std::string* _s = _internal_mutable_ipp_make_and_model();
604 // @@protoc_insertion_point(field_mutable:metrics.PrinterEventProto.ipp_make_and_model)
605 return _s;
606 }
_internal_ipp_make_and_model()607 inline const std::string& PrinterEventProto::_internal_ipp_make_and_model() const {
608 return _impl_.ipp_make_and_model_.Get();
609 }
_internal_set_ipp_make_and_model(const std::string & value)610 inline void PrinterEventProto::_internal_set_ipp_make_and_model(const std::string& value) {
611 _impl_._has_bits_[0] |= 0x00000004u;
612 _impl_.ipp_make_and_model_.Set(value, GetArenaForAllocation());
613 }
_internal_mutable_ipp_make_and_model()614 inline std::string* PrinterEventProto::_internal_mutable_ipp_make_and_model() {
615 _impl_._has_bits_[0] |= 0x00000004u;
616 return _impl_.ipp_make_and_model_.Mutable(GetArenaForAllocation());
617 }
release_ipp_make_and_model()618 inline std::string* PrinterEventProto::release_ipp_make_and_model() {
619 // @@protoc_insertion_point(field_release:metrics.PrinterEventProto.ipp_make_and_model)
620 if (!_internal_has_ipp_make_and_model()) {
621 return nullptr;
622 }
623 _impl_._has_bits_[0] &= ~0x00000004u;
624 auto* p = _impl_.ipp_make_and_model_.Release();
625 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
626 if (_impl_.ipp_make_and_model_.IsDefault()) {
627 _impl_.ipp_make_and_model_.Set("", GetArenaForAllocation());
628 }
629 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
630 return p;
631 }
set_allocated_ipp_make_and_model(std::string * ipp_make_and_model)632 inline void PrinterEventProto::set_allocated_ipp_make_and_model(std::string* ipp_make_and_model) {
633 if (ipp_make_and_model != nullptr) {
634 _impl_._has_bits_[0] |= 0x00000004u;
635 } else {
636 _impl_._has_bits_[0] &= ~0x00000004u;
637 }
638 _impl_.ipp_make_and_model_.SetAllocated(ipp_make_and_model, GetArenaForAllocation());
639 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
640 if (_impl_.ipp_make_and_model_.IsDefault()) {
641 _impl_.ipp_make_and_model_.Set("", GetArenaForAllocation());
642 }
643 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
644 // @@protoc_insertion_point(field_set_allocated:metrics.PrinterEventProto.ipp_make_and_model)
645 }
646
647 // optional bool user_ppd = 6;
_internal_has_user_ppd()648 inline bool PrinterEventProto::_internal_has_user_ppd() const {
649 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
650 return value;
651 }
has_user_ppd()652 inline bool PrinterEventProto::has_user_ppd() const {
653 return _internal_has_user_ppd();
654 }
clear_user_ppd()655 inline void PrinterEventProto::clear_user_ppd() {
656 _impl_.user_ppd_ = false;
657 _impl_._has_bits_[0] &= ~0x00000040u;
658 }
_internal_user_ppd()659 inline bool PrinterEventProto::_internal_user_ppd() const {
660 return _impl_.user_ppd_;
661 }
user_ppd()662 inline bool PrinterEventProto::user_ppd() const {
663 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.user_ppd)
664 return _internal_user_ppd();
665 }
_internal_set_user_ppd(bool value)666 inline void PrinterEventProto::_internal_set_user_ppd(bool value) {
667 _impl_._has_bits_[0] |= 0x00000040u;
668 _impl_.user_ppd_ = value;
669 }
set_user_ppd(bool value)670 inline void PrinterEventProto::set_user_ppd(bool value) {
671 _internal_set_user_ppd(value);
672 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.user_ppd)
673 }
674
675 // optional string ppd_identifier = 7;
_internal_has_ppd_identifier()676 inline bool PrinterEventProto::_internal_has_ppd_identifier() const {
677 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
678 return value;
679 }
has_ppd_identifier()680 inline bool PrinterEventProto::has_ppd_identifier() const {
681 return _internal_has_ppd_identifier();
682 }
clear_ppd_identifier()683 inline void PrinterEventProto::clear_ppd_identifier() {
684 _impl_.ppd_identifier_.ClearToEmpty();
685 _impl_._has_bits_[0] &= ~0x00000008u;
686 }
ppd_identifier()687 inline const std::string& PrinterEventProto::ppd_identifier() const {
688 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.ppd_identifier)
689 return _internal_ppd_identifier();
690 }
691 template <typename ArgT0, typename... ArgT>
692 inline PROTOBUF_ALWAYS_INLINE
set_ppd_identifier(ArgT0 && arg0,ArgT...args)693 void PrinterEventProto::set_ppd_identifier(ArgT0&& arg0, ArgT... args) {
694 _impl_._has_bits_[0] |= 0x00000008u;
695 _impl_.ppd_identifier_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
696 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.ppd_identifier)
697 }
mutable_ppd_identifier()698 inline std::string* PrinterEventProto::mutable_ppd_identifier() {
699 std::string* _s = _internal_mutable_ppd_identifier();
700 // @@protoc_insertion_point(field_mutable:metrics.PrinterEventProto.ppd_identifier)
701 return _s;
702 }
_internal_ppd_identifier()703 inline const std::string& PrinterEventProto::_internal_ppd_identifier() const {
704 return _impl_.ppd_identifier_.Get();
705 }
_internal_set_ppd_identifier(const std::string & value)706 inline void PrinterEventProto::_internal_set_ppd_identifier(const std::string& value) {
707 _impl_._has_bits_[0] |= 0x00000008u;
708 _impl_.ppd_identifier_.Set(value, GetArenaForAllocation());
709 }
_internal_mutable_ppd_identifier()710 inline std::string* PrinterEventProto::_internal_mutable_ppd_identifier() {
711 _impl_._has_bits_[0] |= 0x00000008u;
712 return _impl_.ppd_identifier_.Mutable(GetArenaForAllocation());
713 }
release_ppd_identifier()714 inline std::string* PrinterEventProto::release_ppd_identifier() {
715 // @@protoc_insertion_point(field_release:metrics.PrinterEventProto.ppd_identifier)
716 if (!_internal_has_ppd_identifier()) {
717 return nullptr;
718 }
719 _impl_._has_bits_[0] &= ~0x00000008u;
720 auto* p = _impl_.ppd_identifier_.Release();
721 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
722 if (_impl_.ppd_identifier_.IsDefault()) {
723 _impl_.ppd_identifier_.Set("", GetArenaForAllocation());
724 }
725 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
726 return p;
727 }
set_allocated_ppd_identifier(std::string * ppd_identifier)728 inline void PrinterEventProto::set_allocated_ppd_identifier(std::string* ppd_identifier) {
729 if (ppd_identifier != nullptr) {
730 _impl_._has_bits_[0] |= 0x00000008u;
731 } else {
732 _impl_._has_bits_[0] &= ~0x00000008u;
733 }
734 _impl_.ppd_identifier_.SetAllocated(ppd_identifier, GetArenaForAllocation());
735 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
736 if (_impl_.ppd_identifier_.IsDefault()) {
737 _impl_.ppd_identifier_.Set("", GetArenaForAllocation());
738 }
739 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
740 // @@protoc_insertion_point(field_set_allocated:metrics.PrinterEventProto.ppd_identifier)
741 }
742
743 // optional .metrics.PrinterEventProto.EventType event_type = 8;
_internal_has_event_type()744 inline bool PrinterEventProto::_internal_has_event_type() const {
745 bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
746 return value;
747 }
has_event_type()748 inline bool PrinterEventProto::has_event_type() const {
749 return _internal_has_event_type();
750 }
clear_event_type()751 inline void PrinterEventProto::clear_event_type() {
752 _impl_.event_type_ = 0;
753 _impl_._has_bits_[0] &= ~0x00000080u;
754 }
_internal_event_type()755 inline ::metrics::PrinterEventProto_EventType PrinterEventProto::_internal_event_type() const {
756 return static_cast< ::metrics::PrinterEventProto_EventType >(_impl_.event_type_);
757 }
event_type()758 inline ::metrics::PrinterEventProto_EventType PrinterEventProto::event_type() const {
759 // @@protoc_insertion_point(field_get:metrics.PrinterEventProto.event_type)
760 return _internal_event_type();
761 }
_internal_set_event_type(::metrics::PrinterEventProto_EventType value)762 inline void PrinterEventProto::_internal_set_event_type(::metrics::PrinterEventProto_EventType value) {
763 assert(::metrics::PrinterEventProto_EventType_IsValid(value));
764 _impl_._has_bits_[0] |= 0x00000080u;
765 _impl_.event_type_ = value;
766 }
set_event_type(::metrics::PrinterEventProto_EventType value)767 inline void PrinterEventProto::set_event_type(::metrics::PrinterEventProto_EventType value) {
768 _internal_set_event_type(value);
769 // @@protoc_insertion_point(field_set:metrics.PrinterEventProto.event_type)
770 }
771
772 #ifdef __GNUC__
773 #pragma GCC diagnostic pop
774 #endif // __GNUC__
775
776 // @@protoc_insertion_point(namespace_scope)
777
778 } // namespace metrics
779
780 PROTOBUF_NAMESPACE_OPEN
781
782 template <> struct is_proto_enum< ::metrics::PrinterEventProto_EventType> : ::std::true_type {};
783
784 PROTOBUF_NAMESPACE_CLOSE
785
786 // @@protoc_insertion_point(global_scope)
787
788 #include <google/protobuf/port_undef.inc>
789 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_printer_5fevent_2eproto
790