← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/out/Debug/obj/gen/protoc_out/instaweb/net/instaweb/rewriter/critical_keys.pb.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/out/Debug/obj/gen/protoc_out/instaweb/net/instaweb/rewriter/critical_keys.pb.h
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
// source: net/instaweb/rewriter/critical_keys.proto
3
 
 
4
 
#ifndef PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto__INCLUDED
5
 
#define PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto__INCLUDED
6
 
 
7
 
#include <string>
8
 
 
9
 
#include <google/protobuf/stubs/common.h>
10
 
 
11
 
#if GOOGLE_PROTOBUF_VERSION < 2005000
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 2005000 < GOOGLE_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/generated_message_util.h>
23
 
#include <google/protobuf/message_lite.h>
24
 
#include <google/protobuf/repeated_field.h>
25
 
#include <google/protobuf/extension_set.h>
26
 
// @@protoc_insertion_point(includes)
27
 
 
28
 
namespace net_instaweb {
29
 
 
30
 
// Internal implementation detail -- do not call these.
31
 
void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
32
 
void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
33
 
void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
34
 
 
35
 
class CriticalKeys;
36
 
class CriticalKeys_KeyEvidence;
37
 
class CriticalKeys_PendingNonce;
38
 
 
39
 
// ===================================================================
40
 
 
41
 
class CriticalKeys_KeyEvidence : public ::google::protobuf::MessageLite {
42
 
 public:
43
 
  CriticalKeys_KeyEvidence();
44
 
  virtual ~CriticalKeys_KeyEvidence();
45
 
 
46
 
  CriticalKeys_KeyEvidence(const CriticalKeys_KeyEvidence& from);
47
 
 
48
 
  inline CriticalKeys_KeyEvidence& operator=(const CriticalKeys_KeyEvidence& from) {
49
 
    CopyFrom(from);
50
 
    return *this;
51
 
  }
52
 
 
53
 
  static const CriticalKeys_KeyEvidence& default_instance();
54
 
 
55
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
56
 
  // Returns the internal default instance pointer. This function can
57
 
  // return NULL thus should not be used by the user. This is intended
58
 
  // for Protobuf internal code. Please use default_instance() declared
59
 
  // above instead.
60
 
  static inline const CriticalKeys_KeyEvidence* internal_default_instance() {
61
 
    return default_instance_;
62
 
  }
63
 
  #endif
64
 
 
65
 
  void Swap(CriticalKeys_KeyEvidence* other);
66
 
 
67
 
  // implements Message ----------------------------------------------
68
 
 
69
 
  CriticalKeys_KeyEvidence* New() const;
70
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
71
 
  void CopyFrom(const CriticalKeys_KeyEvidence& from);
72
 
  void MergeFrom(const CriticalKeys_KeyEvidence& from);
73
 
  void Clear();
74
 
  bool IsInitialized() const;
75
 
 
76
 
  int ByteSize() const;
77
 
  bool MergePartialFromCodedStream(
78
 
      ::google::protobuf::io::CodedInputStream* input);
79
 
  void SerializeWithCachedSizes(
80
 
      ::google::protobuf::io::CodedOutputStream* output) const;
81
 
  int GetCachedSize() const { return _cached_size_; }
82
 
  private:
83
 
  void SharedCtor();
84
 
  void SharedDtor();
85
 
  void SetCachedSize(int size) const;
86
 
  public:
87
 
 
88
 
  ::std::string GetTypeName() const;
89
 
 
90
 
  // nested types ----------------------------------------------------
91
 
 
92
 
  // accessors -------------------------------------------------------
93
 
 
94
 
  // optional string key = 1;
95
 
  inline bool has_key() const;
96
 
  inline void clear_key();
97
 
  static const int kKeyFieldNumber = 1;
98
 
  inline const ::std::string& key() const;
99
 
  inline void set_key(const ::std::string& value);
100
 
  inline void set_key(const char* value);
101
 
  inline void set_key(const char* value, size_t size);
102
 
  inline ::std::string* mutable_key();
103
 
  inline ::std::string* release_key();
104
 
  inline void set_allocated_key(::std::string* key);
105
 
 
106
 
  // optional int32 support = 2;
107
 
  inline bool has_support() const;
108
 
  inline void clear_support();
109
 
  static const int kSupportFieldNumber = 2;
110
 
  inline ::google::protobuf::int32 support() const;
111
 
  inline void set_support(::google::protobuf::int32 value);
112
 
 
113
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CriticalKeys.KeyEvidence)
114
 
 private:
115
 
  inline void set_has_key();
116
 
  inline void clear_has_key();
117
 
  inline void set_has_support();
118
 
  inline void clear_has_support();
119
 
 
120
 
  ::std::string* key_;
121
 
  ::google::protobuf::int32 support_;
122
 
 
123
 
  mutable int _cached_size_;
124
 
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
125
 
 
126
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
127
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto_impl();
128
 
  #else
129
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
130
 
  #endif
131
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
132
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
133
 
 
134
 
  void InitAsDefaultInstance();
135
 
  static CriticalKeys_KeyEvidence* default_instance_;
136
 
};
137
 
// -------------------------------------------------------------------
138
 
 
139
 
class CriticalKeys_PendingNonce : public ::google::protobuf::MessageLite {
140
 
 public:
141
 
  CriticalKeys_PendingNonce();
142
 
  virtual ~CriticalKeys_PendingNonce();
143
 
 
144
 
  CriticalKeys_PendingNonce(const CriticalKeys_PendingNonce& from);
145
 
 
146
 
  inline CriticalKeys_PendingNonce& operator=(const CriticalKeys_PendingNonce& from) {
147
 
    CopyFrom(from);
148
 
    return *this;
149
 
  }
150
 
 
151
 
  static const CriticalKeys_PendingNonce& default_instance();
152
 
 
153
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
154
 
  // Returns the internal default instance pointer. This function can
155
 
  // return NULL thus should not be used by the user. This is intended
156
 
  // for Protobuf internal code. Please use default_instance() declared
157
 
  // above instead.
158
 
  static inline const CriticalKeys_PendingNonce* internal_default_instance() {
159
 
    return default_instance_;
160
 
  }
161
 
  #endif
162
 
 
163
 
  void Swap(CriticalKeys_PendingNonce* other);
164
 
 
165
 
  // implements Message ----------------------------------------------
166
 
 
167
 
  CriticalKeys_PendingNonce* New() const;
168
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
169
 
  void CopyFrom(const CriticalKeys_PendingNonce& from);
170
 
  void MergeFrom(const CriticalKeys_PendingNonce& from);
171
 
  void Clear();
172
 
  bool IsInitialized() const;
173
 
 
174
 
  int ByteSize() const;
175
 
  bool MergePartialFromCodedStream(
176
 
      ::google::protobuf::io::CodedInputStream* input);
177
 
  void SerializeWithCachedSizes(
178
 
      ::google::protobuf::io::CodedOutputStream* output) const;
179
 
  int GetCachedSize() const { return _cached_size_; }
180
 
  private:
181
 
  void SharedCtor();
182
 
  void SharedDtor();
183
 
  void SetCachedSize(int size) const;
184
 
  public:
185
 
 
186
 
  ::std::string GetTypeName() const;
187
 
 
188
 
  // nested types ----------------------------------------------------
189
 
 
190
 
  // accessors -------------------------------------------------------
191
 
 
192
 
  // optional int64 timestamp_ms = 1;
193
 
  inline bool has_timestamp_ms() const;
194
 
  inline void clear_timestamp_ms();
195
 
  static const int kTimestampMsFieldNumber = 1;
196
 
  inline ::google::protobuf::int64 timestamp_ms() const;
197
 
  inline void set_timestamp_ms(::google::protobuf::int64 value);
198
 
 
199
 
  // optional string nonce = 2;
200
 
  inline bool has_nonce() const;
201
 
  inline void clear_nonce();
202
 
  static const int kNonceFieldNumber = 2;
203
 
  inline const ::std::string& nonce() const;
204
 
  inline void set_nonce(const ::std::string& value);
205
 
  inline void set_nonce(const char* value);
206
 
  inline void set_nonce(const char* value, size_t size);
207
 
  inline ::std::string* mutable_nonce();
208
 
  inline ::std::string* release_nonce();
209
 
  inline void set_allocated_nonce(::std::string* nonce);
210
 
 
211
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CriticalKeys.PendingNonce)
212
 
 private:
213
 
  inline void set_has_timestamp_ms();
214
 
  inline void clear_has_timestamp_ms();
215
 
  inline void set_has_nonce();
216
 
  inline void clear_has_nonce();
217
 
 
218
 
  ::google::protobuf::int64 timestamp_ms_;
219
 
  ::std::string* nonce_;
220
 
 
221
 
  mutable int _cached_size_;
222
 
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
223
 
 
224
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
225
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto_impl();
226
 
  #else
227
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
228
 
  #endif
229
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
230
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
231
 
 
232
 
  void InitAsDefaultInstance();
233
 
  static CriticalKeys_PendingNonce* default_instance_;
234
 
};
235
 
// -------------------------------------------------------------------
236
 
 
237
 
class CriticalKeys : public ::google::protobuf::MessageLite {
238
 
 public:
239
 
  CriticalKeys();
240
 
  virtual ~CriticalKeys();
241
 
 
242
 
  CriticalKeys(const CriticalKeys& from);
243
 
 
244
 
  inline CriticalKeys& operator=(const CriticalKeys& from) {
245
 
    CopyFrom(from);
246
 
    return *this;
247
 
  }
248
 
 
249
 
  static const CriticalKeys& default_instance();
250
 
 
251
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
252
 
  // Returns the internal default instance pointer. This function can
253
 
  // return NULL thus should not be used by the user. This is intended
254
 
  // for Protobuf internal code. Please use default_instance() declared
255
 
  // above instead.
256
 
  static inline const CriticalKeys* internal_default_instance() {
257
 
    return default_instance_;
258
 
  }
259
 
  #endif
260
 
 
261
 
  void Swap(CriticalKeys* other);
262
 
 
263
 
  // implements Message ----------------------------------------------
264
 
 
265
 
  CriticalKeys* New() const;
266
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
267
 
  void CopyFrom(const CriticalKeys& from);
268
 
  void MergeFrom(const CriticalKeys& from);
269
 
  void Clear();
270
 
  bool IsInitialized() const;
271
 
 
272
 
  int ByteSize() const;
273
 
  bool MergePartialFromCodedStream(
274
 
      ::google::protobuf::io::CodedInputStream* input);
275
 
  void SerializeWithCachedSizes(
276
 
      ::google::protobuf::io::CodedOutputStream* output) const;
277
 
  int GetCachedSize() const { return _cached_size_; }
278
 
  private:
279
 
  void SharedCtor();
280
 
  void SharedDtor();
281
 
  void SetCachedSize(int size) const;
282
 
  public:
283
 
 
284
 
  ::std::string GetTypeName() const;
285
 
 
286
 
  // nested types ----------------------------------------------------
287
 
 
288
 
  typedef CriticalKeys_KeyEvidence KeyEvidence;
289
 
  typedef CriticalKeys_PendingNonce PendingNonce;
290
 
 
291
 
  // accessors -------------------------------------------------------
292
 
 
293
 
  // optional int64 next_beacon_timestamp_ms = 4;
294
 
  inline bool has_next_beacon_timestamp_ms() const;
295
 
  inline void clear_next_beacon_timestamp_ms();
296
 
  static const int kNextBeaconTimestampMsFieldNumber = 4;
297
 
  inline ::google::protobuf::int64 next_beacon_timestamp_ms() const;
298
 
  inline void set_next_beacon_timestamp_ms(::google::protobuf::int64 value);
299
 
 
300
 
  // repeated .net_instaweb.CriticalKeys.KeyEvidence key_evidence = 5;
301
 
  inline int key_evidence_size() const;
302
 
  inline void clear_key_evidence();
303
 
  static const int kKeyEvidenceFieldNumber = 5;
304
 
  inline const ::net_instaweb::CriticalKeys_KeyEvidence& key_evidence(int index) const;
305
 
  inline ::net_instaweb::CriticalKeys_KeyEvidence* mutable_key_evidence(int index);
306
 
  inline ::net_instaweb::CriticalKeys_KeyEvidence* add_key_evidence();
307
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_KeyEvidence >&
308
 
      key_evidence() const;
309
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_KeyEvidence >*
310
 
      mutable_key_evidence();
311
 
 
312
 
  // repeated .net_instaweb.CriticalKeys.PendingNonce pending_nonce = 6;
313
 
  inline int pending_nonce_size() const;
314
 
  inline void clear_pending_nonce();
315
 
  static const int kPendingNonceFieldNumber = 6;
316
 
  inline const ::net_instaweb::CriticalKeys_PendingNonce& pending_nonce(int index) const;
317
 
  inline ::net_instaweb::CriticalKeys_PendingNonce* mutable_pending_nonce(int index);
318
 
  inline ::net_instaweb::CriticalKeys_PendingNonce* add_pending_nonce();
319
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_PendingNonce >&
320
 
      pending_nonce() const;
321
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_PendingNonce >*
322
 
      mutable_pending_nonce();
323
 
 
324
 
  // optional int32 maximum_possible_support = 7 [default = 1];
325
 
  inline bool has_maximum_possible_support() const;
326
 
  inline void clear_maximum_possible_support();
327
 
  static const int kMaximumPossibleSupportFieldNumber = 7;
328
 
  inline ::google::protobuf::int32 maximum_possible_support() const;
329
 
  inline void set_maximum_possible_support(::google::protobuf::int32 value);
330
 
 
331
 
  // optional int64 valid_beacons_received = 8;
332
 
  inline bool has_valid_beacons_received() const;
333
 
  inline void clear_valid_beacons_received();
334
 
  static const int kValidBeaconsReceivedFieldNumber = 8;
335
 
  inline ::google::protobuf::int64 valid_beacons_received() const;
336
 
  inline void set_valid_beacons_received(::google::protobuf::int64 value);
337
 
 
338
 
  // optional int64 nonces_recently_expired = 9;
339
 
  inline bool has_nonces_recently_expired() const;
340
 
  inline void clear_nonces_recently_expired();
341
 
  static const int kNoncesRecentlyExpiredFieldNumber = 9;
342
 
  inline ::google::protobuf::int64 nonces_recently_expired() const;
343
 
  inline void set_nonces_recently_expired(::google::protobuf::int64 value);
344
 
 
345
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CriticalKeys)
346
 
 private:
347
 
  inline void set_has_next_beacon_timestamp_ms();
348
 
  inline void clear_has_next_beacon_timestamp_ms();
349
 
  inline void set_has_maximum_possible_support();
350
 
  inline void clear_has_maximum_possible_support();
351
 
  inline void set_has_valid_beacons_received();
352
 
  inline void clear_has_valid_beacons_received();
353
 
  inline void set_has_nonces_recently_expired();
354
 
  inline void clear_has_nonces_recently_expired();
355
 
 
356
 
  ::google::protobuf::int64 next_beacon_timestamp_ms_;
357
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_KeyEvidence > key_evidence_;
358
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_PendingNonce > pending_nonce_;
359
 
  ::google::protobuf::int64 valid_beacons_received_;
360
 
  ::google::protobuf::int64 nonces_recently_expired_;
361
 
  ::google::protobuf::int32 maximum_possible_support_;
362
 
 
363
 
  mutable int _cached_size_;
364
 
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
365
 
 
366
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
367
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto_impl();
368
 
  #else
369
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
370
 
  #endif
371
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
372
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto();
373
 
 
374
 
  void InitAsDefaultInstance();
375
 
  static CriticalKeys* default_instance_;
376
 
};
377
 
// ===================================================================
378
 
 
379
 
 
380
 
// ===================================================================
381
 
 
382
 
// CriticalKeys_KeyEvidence
383
 
 
384
 
// optional string key = 1;
385
 
inline bool CriticalKeys_KeyEvidence::has_key() const {
386
 
  return (_has_bits_[0] & 0x00000001u) != 0;
387
 
}
388
 
inline void CriticalKeys_KeyEvidence::set_has_key() {
389
 
  _has_bits_[0] |= 0x00000001u;
390
 
}
391
 
inline void CriticalKeys_KeyEvidence::clear_has_key() {
392
 
  _has_bits_[0] &= ~0x00000001u;
393
 
}
394
 
inline void CriticalKeys_KeyEvidence::clear_key() {
395
 
  if (key_ != &::google::protobuf::internal::GetEmptyString()) {
396
 
    key_->clear();
397
 
  }
398
 
  clear_has_key();
399
 
}
400
 
inline const ::std::string& CriticalKeys_KeyEvidence::key() const {
401
 
  return *key_;
402
 
}
403
 
inline void CriticalKeys_KeyEvidence::set_key(const ::std::string& value) {
404
 
  set_has_key();
405
 
  if (key_ == &::google::protobuf::internal::GetEmptyString()) {
406
 
    key_ = new ::std::string;
407
 
  }
408
 
  key_->assign(value);
409
 
}
410
 
inline void CriticalKeys_KeyEvidence::set_key(const char* value) {
411
 
  set_has_key();
412
 
  if (key_ == &::google::protobuf::internal::GetEmptyString()) {
413
 
    key_ = new ::std::string;
414
 
  }
415
 
  key_->assign(value);
416
 
}
417
 
inline void CriticalKeys_KeyEvidence::set_key(const char* value, size_t size) {
418
 
  set_has_key();
419
 
  if (key_ == &::google::protobuf::internal::GetEmptyString()) {
420
 
    key_ = new ::std::string;
421
 
  }
422
 
  key_->assign(reinterpret_cast<const char*>(value), size);
423
 
}
424
 
inline ::std::string* CriticalKeys_KeyEvidence::mutable_key() {
425
 
  set_has_key();
426
 
  if (key_ == &::google::protobuf::internal::GetEmptyString()) {
427
 
    key_ = new ::std::string;
428
 
  }
429
 
  return key_;
430
 
}
431
 
inline ::std::string* CriticalKeys_KeyEvidence::release_key() {
432
 
  clear_has_key();
433
 
  if (key_ == &::google::protobuf::internal::GetEmptyString()) {
434
 
    return NULL;
435
 
  } else {
436
 
    ::std::string* temp = key_;
437
 
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
438
 
    return temp;
439
 
  }
440
 
}
441
 
inline void CriticalKeys_KeyEvidence::set_allocated_key(::std::string* key) {
442
 
  if (key_ != &::google::protobuf::internal::GetEmptyString()) {
443
 
    delete key_;
444
 
  }
445
 
  if (key) {
446
 
    set_has_key();
447
 
    key_ = key;
448
 
  } else {
449
 
    clear_has_key();
450
 
    key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
451
 
  }
452
 
}
453
 
 
454
 
// optional int32 support = 2;
455
 
inline bool CriticalKeys_KeyEvidence::has_support() const {
456
 
  return (_has_bits_[0] & 0x00000002u) != 0;
457
 
}
458
 
inline void CriticalKeys_KeyEvidence::set_has_support() {
459
 
  _has_bits_[0] |= 0x00000002u;
460
 
}
461
 
inline void CriticalKeys_KeyEvidence::clear_has_support() {
462
 
  _has_bits_[0] &= ~0x00000002u;
463
 
}
464
 
inline void CriticalKeys_KeyEvidence::clear_support() {
465
 
  support_ = 0;
466
 
  clear_has_support();
467
 
}
468
 
inline ::google::protobuf::int32 CriticalKeys_KeyEvidence::support() const {
469
 
  return support_;
470
 
}
471
 
inline void CriticalKeys_KeyEvidence::set_support(::google::protobuf::int32 value) {
472
 
  set_has_support();
473
 
  support_ = value;
474
 
}
475
 
 
476
 
// -------------------------------------------------------------------
477
 
 
478
 
// CriticalKeys_PendingNonce
479
 
 
480
 
// optional int64 timestamp_ms = 1;
481
 
inline bool CriticalKeys_PendingNonce::has_timestamp_ms() const {
482
 
  return (_has_bits_[0] & 0x00000001u) != 0;
483
 
}
484
 
inline void CriticalKeys_PendingNonce::set_has_timestamp_ms() {
485
 
  _has_bits_[0] |= 0x00000001u;
486
 
}
487
 
inline void CriticalKeys_PendingNonce::clear_has_timestamp_ms() {
488
 
  _has_bits_[0] &= ~0x00000001u;
489
 
}
490
 
inline void CriticalKeys_PendingNonce::clear_timestamp_ms() {
491
 
  timestamp_ms_ = GOOGLE_LONGLONG(0);
492
 
  clear_has_timestamp_ms();
493
 
}
494
 
inline ::google::protobuf::int64 CriticalKeys_PendingNonce::timestamp_ms() const {
495
 
  return timestamp_ms_;
496
 
}
497
 
inline void CriticalKeys_PendingNonce::set_timestamp_ms(::google::protobuf::int64 value) {
498
 
  set_has_timestamp_ms();
499
 
  timestamp_ms_ = value;
500
 
}
501
 
 
502
 
// optional string nonce = 2;
503
 
inline bool CriticalKeys_PendingNonce::has_nonce() const {
504
 
  return (_has_bits_[0] & 0x00000002u) != 0;
505
 
}
506
 
inline void CriticalKeys_PendingNonce::set_has_nonce() {
507
 
  _has_bits_[0] |= 0x00000002u;
508
 
}
509
 
inline void CriticalKeys_PendingNonce::clear_has_nonce() {
510
 
  _has_bits_[0] &= ~0x00000002u;
511
 
}
512
 
inline void CriticalKeys_PendingNonce::clear_nonce() {
513
 
  if (nonce_ != &::google::protobuf::internal::GetEmptyString()) {
514
 
    nonce_->clear();
515
 
  }
516
 
  clear_has_nonce();
517
 
}
518
 
inline const ::std::string& CriticalKeys_PendingNonce::nonce() const {
519
 
  return *nonce_;
520
 
}
521
 
inline void CriticalKeys_PendingNonce::set_nonce(const ::std::string& value) {
522
 
  set_has_nonce();
523
 
  if (nonce_ == &::google::protobuf::internal::GetEmptyString()) {
524
 
    nonce_ = new ::std::string;
525
 
  }
526
 
  nonce_->assign(value);
527
 
}
528
 
inline void CriticalKeys_PendingNonce::set_nonce(const char* value) {
529
 
  set_has_nonce();
530
 
  if (nonce_ == &::google::protobuf::internal::GetEmptyString()) {
531
 
    nonce_ = new ::std::string;
532
 
  }
533
 
  nonce_->assign(value);
534
 
}
535
 
inline void CriticalKeys_PendingNonce::set_nonce(const char* value, size_t size) {
536
 
  set_has_nonce();
537
 
  if (nonce_ == &::google::protobuf::internal::GetEmptyString()) {
538
 
    nonce_ = new ::std::string;
539
 
  }
540
 
  nonce_->assign(reinterpret_cast<const char*>(value), size);
541
 
}
542
 
inline ::std::string* CriticalKeys_PendingNonce::mutable_nonce() {
543
 
  set_has_nonce();
544
 
  if (nonce_ == &::google::protobuf::internal::GetEmptyString()) {
545
 
    nonce_ = new ::std::string;
546
 
  }
547
 
  return nonce_;
548
 
}
549
 
inline ::std::string* CriticalKeys_PendingNonce::release_nonce() {
550
 
  clear_has_nonce();
551
 
  if (nonce_ == &::google::protobuf::internal::GetEmptyString()) {
552
 
    return NULL;
553
 
  } else {
554
 
    ::std::string* temp = nonce_;
555
 
    nonce_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
556
 
    return temp;
557
 
  }
558
 
}
559
 
inline void CriticalKeys_PendingNonce::set_allocated_nonce(::std::string* nonce) {
560
 
  if (nonce_ != &::google::protobuf::internal::GetEmptyString()) {
561
 
    delete nonce_;
562
 
  }
563
 
  if (nonce) {
564
 
    set_has_nonce();
565
 
    nonce_ = nonce;
566
 
  } else {
567
 
    clear_has_nonce();
568
 
    nonce_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
569
 
  }
570
 
}
571
 
 
572
 
// -------------------------------------------------------------------
573
 
 
574
 
// CriticalKeys
575
 
 
576
 
// optional int64 next_beacon_timestamp_ms = 4;
577
 
inline bool CriticalKeys::has_next_beacon_timestamp_ms() const {
578
 
  return (_has_bits_[0] & 0x00000001u) != 0;
579
 
}
580
 
inline void CriticalKeys::set_has_next_beacon_timestamp_ms() {
581
 
  _has_bits_[0] |= 0x00000001u;
582
 
}
583
 
inline void CriticalKeys::clear_has_next_beacon_timestamp_ms() {
584
 
  _has_bits_[0] &= ~0x00000001u;
585
 
}
586
 
inline void CriticalKeys::clear_next_beacon_timestamp_ms() {
587
 
  next_beacon_timestamp_ms_ = GOOGLE_LONGLONG(0);
588
 
  clear_has_next_beacon_timestamp_ms();
589
 
}
590
 
inline ::google::protobuf::int64 CriticalKeys::next_beacon_timestamp_ms() const {
591
 
  return next_beacon_timestamp_ms_;
592
 
}
593
 
inline void CriticalKeys::set_next_beacon_timestamp_ms(::google::protobuf::int64 value) {
594
 
  set_has_next_beacon_timestamp_ms();
595
 
  next_beacon_timestamp_ms_ = value;
596
 
}
597
 
 
598
 
// repeated .net_instaweb.CriticalKeys.KeyEvidence key_evidence = 5;
599
 
inline int CriticalKeys::key_evidence_size() const {
600
 
  return key_evidence_.size();
601
 
}
602
 
inline void CriticalKeys::clear_key_evidence() {
603
 
  key_evidence_.Clear();
604
 
}
605
 
inline const ::net_instaweb::CriticalKeys_KeyEvidence& CriticalKeys::key_evidence(int index) const {
606
 
  return key_evidence_.Get(index);
607
 
}
608
 
inline ::net_instaweb::CriticalKeys_KeyEvidence* CriticalKeys::mutable_key_evidence(int index) {
609
 
  return key_evidence_.Mutable(index);
610
 
}
611
 
inline ::net_instaweb::CriticalKeys_KeyEvidence* CriticalKeys::add_key_evidence() {
612
 
  return key_evidence_.Add();
613
 
}
614
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_KeyEvidence >&
615
 
CriticalKeys::key_evidence() const {
616
 
  return key_evidence_;
617
 
}
618
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_KeyEvidence >*
619
 
CriticalKeys::mutable_key_evidence() {
620
 
  return &key_evidence_;
621
 
}
622
 
 
623
 
// repeated .net_instaweb.CriticalKeys.PendingNonce pending_nonce = 6;
624
 
inline int CriticalKeys::pending_nonce_size() const {
625
 
  return pending_nonce_.size();
626
 
}
627
 
inline void CriticalKeys::clear_pending_nonce() {
628
 
  pending_nonce_.Clear();
629
 
}
630
 
inline const ::net_instaweb::CriticalKeys_PendingNonce& CriticalKeys::pending_nonce(int index) const {
631
 
  return pending_nonce_.Get(index);
632
 
}
633
 
inline ::net_instaweb::CriticalKeys_PendingNonce* CriticalKeys::mutable_pending_nonce(int index) {
634
 
  return pending_nonce_.Mutable(index);
635
 
}
636
 
inline ::net_instaweb::CriticalKeys_PendingNonce* CriticalKeys::add_pending_nonce() {
637
 
  return pending_nonce_.Add();
638
 
}
639
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_PendingNonce >&
640
 
CriticalKeys::pending_nonce() const {
641
 
  return pending_nonce_;
642
 
}
643
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalKeys_PendingNonce >*
644
 
CriticalKeys::mutable_pending_nonce() {
645
 
  return &pending_nonce_;
646
 
}
647
 
 
648
 
// optional int32 maximum_possible_support = 7 [default = 1];
649
 
inline bool CriticalKeys::has_maximum_possible_support() const {
650
 
  return (_has_bits_[0] & 0x00000008u) != 0;
651
 
}
652
 
inline void CriticalKeys::set_has_maximum_possible_support() {
653
 
  _has_bits_[0] |= 0x00000008u;
654
 
}
655
 
inline void CriticalKeys::clear_has_maximum_possible_support() {
656
 
  _has_bits_[0] &= ~0x00000008u;
657
 
}
658
 
inline void CriticalKeys::clear_maximum_possible_support() {
659
 
  maximum_possible_support_ = 1;
660
 
  clear_has_maximum_possible_support();
661
 
}
662
 
inline ::google::protobuf::int32 CriticalKeys::maximum_possible_support() const {
663
 
  return maximum_possible_support_;
664
 
}
665
 
inline void CriticalKeys::set_maximum_possible_support(::google::protobuf::int32 value) {
666
 
  set_has_maximum_possible_support();
667
 
  maximum_possible_support_ = value;
668
 
}
669
 
 
670
 
// optional int64 valid_beacons_received = 8;
671
 
inline bool CriticalKeys::has_valid_beacons_received() const {
672
 
  return (_has_bits_[0] & 0x00000010u) != 0;
673
 
}
674
 
inline void CriticalKeys::set_has_valid_beacons_received() {
675
 
  _has_bits_[0] |= 0x00000010u;
676
 
}
677
 
inline void CriticalKeys::clear_has_valid_beacons_received() {
678
 
  _has_bits_[0] &= ~0x00000010u;
679
 
}
680
 
inline void CriticalKeys::clear_valid_beacons_received() {
681
 
  valid_beacons_received_ = GOOGLE_LONGLONG(0);
682
 
  clear_has_valid_beacons_received();
683
 
}
684
 
inline ::google::protobuf::int64 CriticalKeys::valid_beacons_received() const {
685
 
  return valid_beacons_received_;
686
 
}
687
 
inline void CriticalKeys::set_valid_beacons_received(::google::protobuf::int64 value) {
688
 
  set_has_valid_beacons_received();
689
 
  valid_beacons_received_ = value;
690
 
}
691
 
 
692
 
// optional int64 nonces_recently_expired = 9;
693
 
inline bool CriticalKeys::has_nonces_recently_expired() const {
694
 
  return (_has_bits_[0] & 0x00000020u) != 0;
695
 
}
696
 
inline void CriticalKeys::set_has_nonces_recently_expired() {
697
 
  _has_bits_[0] |= 0x00000020u;
698
 
}
699
 
inline void CriticalKeys::clear_has_nonces_recently_expired() {
700
 
  _has_bits_[0] &= ~0x00000020u;
701
 
}
702
 
inline void CriticalKeys::clear_nonces_recently_expired() {
703
 
  nonces_recently_expired_ = GOOGLE_LONGLONG(0);
704
 
  clear_has_nonces_recently_expired();
705
 
}
706
 
inline ::google::protobuf::int64 CriticalKeys::nonces_recently_expired() const {
707
 
  return nonces_recently_expired_;
708
 
}
709
 
inline void CriticalKeys::set_nonces_recently_expired(::google::protobuf::int64 value) {
710
 
  set_has_nonces_recently_expired();
711
 
  nonces_recently_expired_ = value;
712
 
}
713
 
 
714
 
 
715
 
// @@protoc_insertion_point(namespace_scope)
716
 
 
717
 
}  // namespace net_instaweb
718
 
 
719
 
// @@protoc_insertion_point(global_scope)
720
 
 
721
 
#endif  // PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fkeys_2eproto__INCLUDED