← 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/cache_html_info.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/cache_html_info.pb.h
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
// source: net/instaweb/rewriter/cache_html_info.proto
3
 
 
4
 
#ifndef PROTOBUF_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto__INCLUDED
5
 
#define PROTOBUF_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_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_2fcache_5fhtml_5finfo_2eproto();
32
 
void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
33
 
void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
34
 
 
35
 
class CacheHtmlInfo;
36
 
class CacheDiffInfo;
37
 
 
38
 
// ===================================================================
39
 
 
40
 
class CacheHtmlInfo : public ::google::protobuf::MessageLite {
41
 
 public:
42
 
  CacheHtmlInfo();
43
 
  virtual ~CacheHtmlInfo();
44
 
 
45
 
  CacheHtmlInfo(const CacheHtmlInfo& from);
46
 
 
47
 
  inline CacheHtmlInfo& operator=(const CacheHtmlInfo& from) {
48
 
    CopyFrom(from);
49
 
    return *this;
50
 
  }
51
 
 
52
 
  static const CacheHtmlInfo& default_instance();
53
 
 
54
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
55
 
  // Returns the internal default instance pointer. This function can
56
 
  // return NULL thus should not be used by the user. This is intended
57
 
  // for Protobuf internal code. Please use default_instance() declared
58
 
  // above instead.
59
 
  static inline const CacheHtmlInfo* internal_default_instance() {
60
 
    return default_instance_;
61
 
  }
62
 
  #endif
63
 
 
64
 
  void Swap(CacheHtmlInfo* other);
65
 
 
66
 
  // implements Message ----------------------------------------------
67
 
 
68
 
  CacheHtmlInfo* New() const;
69
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
70
 
  void CopyFrom(const CacheHtmlInfo& from);
71
 
  void MergeFrom(const CacheHtmlInfo& from);
72
 
  void Clear();
73
 
  bool IsInitialized() const;
74
 
 
75
 
  int ByteSize() const;
76
 
  bool MergePartialFromCodedStream(
77
 
      ::google::protobuf::io::CodedInputStream* input);
78
 
  void SerializeWithCachedSizes(
79
 
      ::google::protobuf::io::CodedOutputStream* output) const;
80
 
  int GetCachedSize() const { return _cached_size_; }
81
 
  private:
82
 
  void SharedCtor();
83
 
  void SharedDtor();
84
 
  void SetCachedSize(int size) const;
85
 
  public:
86
 
 
87
 
  ::std::string GetTypeName() const;
88
 
 
89
 
  // nested types ----------------------------------------------------
90
 
 
91
 
  // accessors -------------------------------------------------------
92
 
 
93
 
  // optional bytes cached_html = 1;
94
 
  inline bool has_cached_html() const;
95
 
  inline void clear_cached_html();
96
 
  static const int kCachedHtmlFieldNumber = 1;
97
 
  inline const ::std::string& cached_html() const;
98
 
  inline void set_cached_html(const ::std::string& value);
99
 
  inline void set_cached_html(const char* value);
100
 
  inline void set_cached_html(const void* value, size_t size);
101
 
  inline ::std::string* mutable_cached_html();
102
 
  inline ::std::string* release_cached_html();
103
 
  inline void set_allocated_cached_html(::std::string* cached_html);
104
 
 
105
 
  // optional string hash = 2;
106
 
  inline bool has_hash() const;
107
 
  inline void clear_hash();
108
 
  static const int kHashFieldNumber = 2;
109
 
  inline const ::std::string& hash() const;
110
 
  inline void set_hash(const ::std::string& value);
111
 
  inline void set_hash(const char* value);
112
 
  inline void set_hash(const char* value, size_t size);
113
 
  inline ::std::string* mutable_hash();
114
 
  inline ::std::string* release_hash();
115
 
  inline void set_allocated_hash(::std::string* hash);
116
 
 
117
 
  // optional int64 last_cached_html_computation_timestamp_ms = 3;
118
 
  inline bool has_last_cached_html_computation_timestamp_ms() const;
119
 
  inline void clear_last_cached_html_computation_timestamp_ms();
120
 
  static const int kLastCachedHtmlComputationTimestampMsFieldNumber = 3;
121
 
  inline ::google::protobuf::int64 last_cached_html_computation_timestamp_ms() const;
122
 
  inline void set_last_cached_html_computation_timestamp_ms(::google::protobuf::int64 value);
123
 
 
124
 
  // optional string hash_smart_diff = 4;
125
 
  inline bool has_hash_smart_diff() const;
126
 
  inline void clear_hash_smart_diff();
127
 
  static const int kHashSmartDiffFieldNumber = 4;
128
 
  inline const ::std::string& hash_smart_diff() const;
129
 
  inline void set_hash_smart_diff(const ::std::string& value);
130
 
  inline void set_hash_smart_diff(const char* value);
131
 
  inline void set_hash_smart_diff(const char* value, size_t size);
132
 
  inline ::std::string* mutable_hash_smart_diff();
133
 
  inline ::std::string* release_hash_smart_diff();
134
 
  inline void set_allocated_hash_smart_diff(::std::string* hash_smart_diff);
135
 
 
136
 
  // optional string charset = 5;
137
 
  inline bool has_charset() const;
138
 
  inline void clear_charset();
139
 
  static const int kCharsetFieldNumber = 5;
140
 
  inline const ::std::string& charset() const;
141
 
  inline void set_charset(const ::std::string& value);
142
 
  inline void set_charset(const char* value);
143
 
  inline void set_charset(const char* value, size_t size);
144
 
  inline ::std::string* mutable_charset();
145
 
  inline ::std::string* release_charset();
146
 
  inline void set_allocated_charset(::std::string* charset);
147
 
 
148
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CacheHtmlInfo)
149
 
 private:
150
 
  inline void set_has_cached_html();
151
 
  inline void clear_has_cached_html();
152
 
  inline void set_has_hash();
153
 
  inline void clear_has_hash();
154
 
  inline void set_has_last_cached_html_computation_timestamp_ms();
155
 
  inline void clear_has_last_cached_html_computation_timestamp_ms();
156
 
  inline void set_has_hash_smart_diff();
157
 
  inline void clear_has_hash_smart_diff();
158
 
  inline void set_has_charset();
159
 
  inline void clear_has_charset();
160
 
 
161
 
  ::std::string* cached_html_;
162
 
  ::std::string* hash_;
163
 
  ::google::protobuf::int64 last_cached_html_computation_timestamp_ms_;
164
 
  ::std::string* hash_smart_diff_;
165
 
  ::std::string* charset_;
166
 
 
167
 
  mutable int _cached_size_;
168
 
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
169
 
 
170
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
171
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto_impl();
172
 
  #else
173
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
174
 
  #endif
175
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
176
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
177
 
 
178
 
  void InitAsDefaultInstance();
179
 
  static CacheHtmlInfo* default_instance_;
180
 
};
181
 
// -------------------------------------------------------------------
182
 
 
183
 
class CacheDiffInfo : public ::google::protobuf::MessageLite {
184
 
 public:
185
 
  CacheDiffInfo();
186
 
  virtual ~CacheDiffInfo();
187
 
 
188
 
  CacheDiffInfo(const CacheDiffInfo& from);
189
 
 
190
 
  inline CacheDiffInfo& operator=(const CacheDiffInfo& from) {
191
 
    CopyFrom(from);
192
 
    return *this;
193
 
  }
194
 
 
195
 
  static const CacheDiffInfo& default_instance();
196
 
 
197
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
198
 
  // Returns the internal default instance pointer. This function can
199
 
  // return NULL thus should not be used by the user. This is intended
200
 
  // for Protobuf internal code. Please use default_instance() declared
201
 
  // above instead.
202
 
  static inline const CacheDiffInfo* internal_default_instance() {
203
 
    return default_instance_;
204
 
  }
205
 
  #endif
206
 
 
207
 
  void Swap(CacheDiffInfo* other);
208
 
 
209
 
  // implements Message ----------------------------------------------
210
 
 
211
 
  CacheDiffInfo* New() const;
212
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
213
 
  void CopyFrom(const CacheDiffInfo& from);
214
 
  void MergeFrom(const CacheDiffInfo& from);
215
 
  void Clear();
216
 
  bool IsInitialized() const;
217
 
 
218
 
  int ByteSize() const;
219
 
  bool MergePartialFromCodedStream(
220
 
      ::google::protobuf::io::CodedInputStream* input);
221
 
  void SerializeWithCachedSizes(
222
 
      ::google::protobuf::io::CodedOutputStream* output) const;
223
 
  int GetCachedSize() const { return _cached_size_; }
224
 
  private:
225
 
  void SharedCtor();
226
 
  void SharedDtor();
227
 
  void SetCachedSize(int size) const;
228
 
  public:
229
 
 
230
 
  ::std::string GetTypeName() const;
231
 
 
232
 
  // nested types ----------------------------------------------------
233
 
 
234
 
  // accessors -------------------------------------------------------
235
 
 
236
 
  // optional string diff_match_history = 1;
237
 
  inline bool has_diff_match_history() const;
238
 
  inline void clear_diff_match_history();
239
 
  static const int kDiffMatchHistoryFieldNumber = 1;
240
 
  inline const ::std::string& diff_match_history() const;
241
 
  inline void set_diff_match_history(const ::std::string& value);
242
 
  inline void set_diff_match_history(const char* value);
243
 
  inline void set_diff_match_history(const char* value, size_t size);
244
 
  inline ::std::string* mutable_diff_match_history();
245
 
  inline ::std::string* release_diff_match_history();
246
 
  inline void set_allocated_diff_match_history(::std::string* diff_match_history);
247
 
 
248
 
  // optional int64 blacklist_timestamp_ms = 2;
249
 
  inline bool has_blacklist_timestamp_ms() const;
250
 
  inline void clear_blacklist_timestamp_ms();
251
 
  static const int kBlacklistTimestampMsFieldNumber = 2;
252
 
  inline ::google::protobuf::int64 blacklist_timestamp_ms() const;
253
 
  inline void set_blacklist_timestamp_ms(::google::protobuf::int64 value);
254
 
 
255
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CacheDiffInfo)
256
 
 private:
257
 
  inline void set_has_diff_match_history();
258
 
  inline void clear_has_diff_match_history();
259
 
  inline void set_has_blacklist_timestamp_ms();
260
 
  inline void clear_has_blacklist_timestamp_ms();
261
 
 
262
 
  ::std::string* diff_match_history_;
263
 
  ::google::protobuf::int64 blacklist_timestamp_ms_;
264
 
 
265
 
  mutable int _cached_size_;
266
 
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
267
 
 
268
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
269
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto_impl();
270
 
  #else
271
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
272
 
  #endif
273
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
274
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto();
275
 
 
276
 
  void InitAsDefaultInstance();
277
 
  static CacheDiffInfo* default_instance_;
278
 
};
279
 
// ===================================================================
280
 
 
281
 
 
282
 
// ===================================================================
283
 
 
284
 
// CacheHtmlInfo
285
 
 
286
 
// optional bytes cached_html = 1;
287
 
inline bool CacheHtmlInfo::has_cached_html() const {
288
 
  return (_has_bits_[0] & 0x00000001u) != 0;
289
 
}
290
 
inline void CacheHtmlInfo::set_has_cached_html() {
291
 
  _has_bits_[0] |= 0x00000001u;
292
 
}
293
 
inline void CacheHtmlInfo::clear_has_cached_html() {
294
 
  _has_bits_[0] &= ~0x00000001u;
295
 
}
296
 
inline void CacheHtmlInfo::clear_cached_html() {
297
 
  if (cached_html_ != &::google::protobuf::internal::GetEmptyString()) {
298
 
    cached_html_->clear();
299
 
  }
300
 
  clear_has_cached_html();
301
 
}
302
 
inline const ::std::string& CacheHtmlInfo::cached_html() const {
303
 
  return *cached_html_;
304
 
}
305
 
inline void CacheHtmlInfo::set_cached_html(const ::std::string& value) {
306
 
  set_has_cached_html();
307
 
  if (cached_html_ == &::google::protobuf::internal::GetEmptyString()) {
308
 
    cached_html_ = new ::std::string;
309
 
  }
310
 
  cached_html_->assign(value);
311
 
}
312
 
inline void CacheHtmlInfo::set_cached_html(const char* value) {
313
 
  set_has_cached_html();
314
 
  if (cached_html_ == &::google::protobuf::internal::GetEmptyString()) {
315
 
    cached_html_ = new ::std::string;
316
 
  }
317
 
  cached_html_->assign(value);
318
 
}
319
 
inline void CacheHtmlInfo::set_cached_html(const void* value, size_t size) {
320
 
  set_has_cached_html();
321
 
  if (cached_html_ == &::google::protobuf::internal::GetEmptyString()) {
322
 
    cached_html_ = new ::std::string;
323
 
  }
324
 
  cached_html_->assign(reinterpret_cast<const char*>(value), size);
325
 
}
326
 
inline ::std::string* CacheHtmlInfo::mutable_cached_html() {
327
 
  set_has_cached_html();
328
 
  if (cached_html_ == &::google::protobuf::internal::GetEmptyString()) {
329
 
    cached_html_ = new ::std::string;
330
 
  }
331
 
  return cached_html_;
332
 
}
333
 
inline ::std::string* CacheHtmlInfo::release_cached_html() {
334
 
  clear_has_cached_html();
335
 
  if (cached_html_ == &::google::protobuf::internal::GetEmptyString()) {
336
 
    return NULL;
337
 
  } else {
338
 
    ::std::string* temp = cached_html_;
339
 
    cached_html_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
340
 
    return temp;
341
 
  }
342
 
}
343
 
inline void CacheHtmlInfo::set_allocated_cached_html(::std::string* cached_html) {
344
 
  if (cached_html_ != &::google::protobuf::internal::GetEmptyString()) {
345
 
    delete cached_html_;
346
 
  }
347
 
  if (cached_html) {
348
 
    set_has_cached_html();
349
 
    cached_html_ = cached_html;
350
 
  } else {
351
 
    clear_has_cached_html();
352
 
    cached_html_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
353
 
  }
354
 
}
355
 
 
356
 
// optional string hash = 2;
357
 
inline bool CacheHtmlInfo::has_hash() const {
358
 
  return (_has_bits_[0] & 0x00000002u) != 0;
359
 
}
360
 
inline void CacheHtmlInfo::set_has_hash() {
361
 
  _has_bits_[0] |= 0x00000002u;
362
 
}
363
 
inline void CacheHtmlInfo::clear_has_hash() {
364
 
  _has_bits_[0] &= ~0x00000002u;
365
 
}
366
 
inline void CacheHtmlInfo::clear_hash() {
367
 
  if (hash_ != &::google::protobuf::internal::GetEmptyString()) {
368
 
    hash_->clear();
369
 
  }
370
 
  clear_has_hash();
371
 
}
372
 
inline const ::std::string& CacheHtmlInfo::hash() const {
373
 
  return *hash_;
374
 
}
375
 
inline void CacheHtmlInfo::set_hash(const ::std::string& value) {
376
 
  set_has_hash();
377
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
378
 
    hash_ = new ::std::string;
379
 
  }
380
 
  hash_->assign(value);
381
 
}
382
 
inline void CacheHtmlInfo::set_hash(const char* value) {
383
 
  set_has_hash();
384
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
385
 
    hash_ = new ::std::string;
386
 
  }
387
 
  hash_->assign(value);
388
 
}
389
 
inline void CacheHtmlInfo::set_hash(const char* value, size_t size) {
390
 
  set_has_hash();
391
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
392
 
    hash_ = new ::std::string;
393
 
  }
394
 
  hash_->assign(reinterpret_cast<const char*>(value), size);
395
 
}
396
 
inline ::std::string* CacheHtmlInfo::mutable_hash() {
397
 
  set_has_hash();
398
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
399
 
    hash_ = new ::std::string;
400
 
  }
401
 
  return hash_;
402
 
}
403
 
inline ::std::string* CacheHtmlInfo::release_hash() {
404
 
  clear_has_hash();
405
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
406
 
    return NULL;
407
 
  } else {
408
 
    ::std::string* temp = hash_;
409
 
    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
410
 
    return temp;
411
 
  }
412
 
}
413
 
inline void CacheHtmlInfo::set_allocated_hash(::std::string* hash) {
414
 
  if (hash_ != &::google::protobuf::internal::GetEmptyString()) {
415
 
    delete hash_;
416
 
  }
417
 
  if (hash) {
418
 
    set_has_hash();
419
 
    hash_ = hash;
420
 
  } else {
421
 
    clear_has_hash();
422
 
    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
423
 
  }
424
 
}
425
 
 
426
 
// optional int64 last_cached_html_computation_timestamp_ms = 3;
427
 
inline bool CacheHtmlInfo::has_last_cached_html_computation_timestamp_ms() const {
428
 
  return (_has_bits_[0] & 0x00000004u) != 0;
429
 
}
430
 
inline void CacheHtmlInfo::set_has_last_cached_html_computation_timestamp_ms() {
431
 
  _has_bits_[0] |= 0x00000004u;
432
 
}
433
 
inline void CacheHtmlInfo::clear_has_last_cached_html_computation_timestamp_ms() {
434
 
  _has_bits_[0] &= ~0x00000004u;
435
 
}
436
 
inline void CacheHtmlInfo::clear_last_cached_html_computation_timestamp_ms() {
437
 
  last_cached_html_computation_timestamp_ms_ = GOOGLE_LONGLONG(0);
438
 
  clear_has_last_cached_html_computation_timestamp_ms();
439
 
}
440
 
inline ::google::protobuf::int64 CacheHtmlInfo::last_cached_html_computation_timestamp_ms() const {
441
 
  return last_cached_html_computation_timestamp_ms_;
442
 
}
443
 
inline void CacheHtmlInfo::set_last_cached_html_computation_timestamp_ms(::google::protobuf::int64 value) {
444
 
  set_has_last_cached_html_computation_timestamp_ms();
445
 
  last_cached_html_computation_timestamp_ms_ = value;
446
 
}
447
 
 
448
 
// optional string hash_smart_diff = 4;
449
 
inline bool CacheHtmlInfo::has_hash_smart_diff() const {
450
 
  return (_has_bits_[0] & 0x00000008u) != 0;
451
 
}
452
 
inline void CacheHtmlInfo::set_has_hash_smart_diff() {
453
 
  _has_bits_[0] |= 0x00000008u;
454
 
}
455
 
inline void CacheHtmlInfo::clear_has_hash_smart_diff() {
456
 
  _has_bits_[0] &= ~0x00000008u;
457
 
}
458
 
inline void CacheHtmlInfo::clear_hash_smart_diff() {
459
 
  if (hash_smart_diff_ != &::google::protobuf::internal::GetEmptyString()) {
460
 
    hash_smart_diff_->clear();
461
 
  }
462
 
  clear_has_hash_smart_diff();
463
 
}
464
 
inline const ::std::string& CacheHtmlInfo::hash_smart_diff() const {
465
 
  return *hash_smart_diff_;
466
 
}
467
 
inline void CacheHtmlInfo::set_hash_smart_diff(const ::std::string& value) {
468
 
  set_has_hash_smart_diff();
469
 
  if (hash_smart_diff_ == &::google::protobuf::internal::GetEmptyString()) {
470
 
    hash_smart_diff_ = new ::std::string;
471
 
  }
472
 
  hash_smart_diff_->assign(value);
473
 
}
474
 
inline void CacheHtmlInfo::set_hash_smart_diff(const char* value) {
475
 
  set_has_hash_smart_diff();
476
 
  if (hash_smart_diff_ == &::google::protobuf::internal::GetEmptyString()) {
477
 
    hash_smart_diff_ = new ::std::string;
478
 
  }
479
 
  hash_smart_diff_->assign(value);
480
 
}
481
 
inline void CacheHtmlInfo::set_hash_smart_diff(const char* value, size_t size) {
482
 
  set_has_hash_smart_diff();
483
 
  if (hash_smart_diff_ == &::google::protobuf::internal::GetEmptyString()) {
484
 
    hash_smart_diff_ = new ::std::string;
485
 
  }
486
 
  hash_smart_diff_->assign(reinterpret_cast<const char*>(value), size);
487
 
}
488
 
inline ::std::string* CacheHtmlInfo::mutable_hash_smart_diff() {
489
 
  set_has_hash_smart_diff();
490
 
  if (hash_smart_diff_ == &::google::protobuf::internal::GetEmptyString()) {
491
 
    hash_smart_diff_ = new ::std::string;
492
 
  }
493
 
  return hash_smart_diff_;
494
 
}
495
 
inline ::std::string* CacheHtmlInfo::release_hash_smart_diff() {
496
 
  clear_has_hash_smart_diff();
497
 
  if (hash_smart_diff_ == &::google::protobuf::internal::GetEmptyString()) {
498
 
    return NULL;
499
 
  } else {
500
 
    ::std::string* temp = hash_smart_diff_;
501
 
    hash_smart_diff_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
502
 
    return temp;
503
 
  }
504
 
}
505
 
inline void CacheHtmlInfo::set_allocated_hash_smart_diff(::std::string* hash_smart_diff) {
506
 
  if (hash_smart_diff_ != &::google::protobuf::internal::GetEmptyString()) {
507
 
    delete hash_smart_diff_;
508
 
  }
509
 
  if (hash_smart_diff) {
510
 
    set_has_hash_smart_diff();
511
 
    hash_smart_diff_ = hash_smart_diff;
512
 
  } else {
513
 
    clear_has_hash_smart_diff();
514
 
    hash_smart_diff_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
515
 
  }
516
 
}
517
 
 
518
 
// optional string charset = 5;
519
 
inline bool CacheHtmlInfo::has_charset() const {
520
 
  return (_has_bits_[0] & 0x00000010u) != 0;
521
 
}
522
 
inline void CacheHtmlInfo::set_has_charset() {
523
 
  _has_bits_[0] |= 0x00000010u;
524
 
}
525
 
inline void CacheHtmlInfo::clear_has_charset() {
526
 
  _has_bits_[0] &= ~0x00000010u;
527
 
}
528
 
inline void CacheHtmlInfo::clear_charset() {
529
 
  if (charset_ != &::google::protobuf::internal::GetEmptyString()) {
530
 
    charset_->clear();
531
 
  }
532
 
  clear_has_charset();
533
 
}
534
 
inline const ::std::string& CacheHtmlInfo::charset() const {
535
 
  return *charset_;
536
 
}
537
 
inline void CacheHtmlInfo::set_charset(const ::std::string& value) {
538
 
  set_has_charset();
539
 
  if (charset_ == &::google::protobuf::internal::GetEmptyString()) {
540
 
    charset_ = new ::std::string;
541
 
  }
542
 
  charset_->assign(value);
543
 
}
544
 
inline void CacheHtmlInfo::set_charset(const char* value) {
545
 
  set_has_charset();
546
 
  if (charset_ == &::google::protobuf::internal::GetEmptyString()) {
547
 
    charset_ = new ::std::string;
548
 
  }
549
 
  charset_->assign(value);
550
 
}
551
 
inline void CacheHtmlInfo::set_charset(const char* value, size_t size) {
552
 
  set_has_charset();
553
 
  if (charset_ == &::google::protobuf::internal::GetEmptyString()) {
554
 
    charset_ = new ::std::string;
555
 
  }
556
 
  charset_->assign(reinterpret_cast<const char*>(value), size);
557
 
}
558
 
inline ::std::string* CacheHtmlInfo::mutable_charset() {
559
 
  set_has_charset();
560
 
  if (charset_ == &::google::protobuf::internal::GetEmptyString()) {
561
 
    charset_ = new ::std::string;
562
 
  }
563
 
  return charset_;
564
 
}
565
 
inline ::std::string* CacheHtmlInfo::release_charset() {
566
 
  clear_has_charset();
567
 
  if (charset_ == &::google::protobuf::internal::GetEmptyString()) {
568
 
    return NULL;
569
 
  } else {
570
 
    ::std::string* temp = charset_;
571
 
    charset_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
572
 
    return temp;
573
 
  }
574
 
}
575
 
inline void CacheHtmlInfo::set_allocated_charset(::std::string* charset) {
576
 
  if (charset_ != &::google::protobuf::internal::GetEmptyString()) {
577
 
    delete charset_;
578
 
  }
579
 
  if (charset) {
580
 
    set_has_charset();
581
 
    charset_ = charset;
582
 
  } else {
583
 
    clear_has_charset();
584
 
    charset_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
585
 
  }
586
 
}
587
 
 
588
 
// -------------------------------------------------------------------
589
 
 
590
 
// CacheDiffInfo
591
 
 
592
 
// optional string diff_match_history = 1;
593
 
inline bool CacheDiffInfo::has_diff_match_history() const {
594
 
  return (_has_bits_[0] & 0x00000001u) != 0;
595
 
}
596
 
inline void CacheDiffInfo::set_has_diff_match_history() {
597
 
  _has_bits_[0] |= 0x00000001u;
598
 
}
599
 
inline void CacheDiffInfo::clear_has_diff_match_history() {
600
 
  _has_bits_[0] &= ~0x00000001u;
601
 
}
602
 
inline void CacheDiffInfo::clear_diff_match_history() {
603
 
  if (diff_match_history_ != &::google::protobuf::internal::GetEmptyString()) {
604
 
    diff_match_history_->clear();
605
 
  }
606
 
  clear_has_diff_match_history();
607
 
}
608
 
inline const ::std::string& CacheDiffInfo::diff_match_history() const {
609
 
  return *diff_match_history_;
610
 
}
611
 
inline void CacheDiffInfo::set_diff_match_history(const ::std::string& value) {
612
 
  set_has_diff_match_history();
613
 
  if (diff_match_history_ == &::google::protobuf::internal::GetEmptyString()) {
614
 
    diff_match_history_ = new ::std::string;
615
 
  }
616
 
  diff_match_history_->assign(value);
617
 
}
618
 
inline void CacheDiffInfo::set_diff_match_history(const char* value) {
619
 
  set_has_diff_match_history();
620
 
  if (diff_match_history_ == &::google::protobuf::internal::GetEmptyString()) {
621
 
    diff_match_history_ = new ::std::string;
622
 
  }
623
 
  diff_match_history_->assign(value);
624
 
}
625
 
inline void CacheDiffInfo::set_diff_match_history(const char* value, size_t size) {
626
 
  set_has_diff_match_history();
627
 
  if (diff_match_history_ == &::google::protobuf::internal::GetEmptyString()) {
628
 
    diff_match_history_ = new ::std::string;
629
 
  }
630
 
  diff_match_history_->assign(reinterpret_cast<const char*>(value), size);
631
 
}
632
 
inline ::std::string* CacheDiffInfo::mutable_diff_match_history() {
633
 
  set_has_diff_match_history();
634
 
  if (diff_match_history_ == &::google::protobuf::internal::GetEmptyString()) {
635
 
    diff_match_history_ = new ::std::string;
636
 
  }
637
 
  return diff_match_history_;
638
 
}
639
 
inline ::std::string* CacheDiffInfo::release_diff_match_history() {
640
 
  clear_has_diff_match_history();
641
 
  if (diff_match_history_ == &::google::protobuf::internal::GetEmptyString()) {
642
 
    return NULL;
643
 
  } else {
644
 
    ::std::string* temp = diff_match_history_;
645
 
    diff_match_history_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
646
 
    return temp;
647
 
  }
648
 
}
649
 
inline void CacheDiffInfo::set_allocated_diff_match_history(::std::string* diff_match_history) {
650
 
  if (diff_match_history_ != &::google::protobuf::internal::GetEmptyString()) {
651
 
    delete diff_match_history_;
652
 
  }
653
 
  if (diff_match_history) {
654
 
    set_has_diff_match_history();
655
 
    diff_match_history_ = diff_match_history;
656
 
  } else {
657
 
    clear_has_diff_match_history();
658
 
    diff_match_history_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
659
 
  }
660
 
}
661
 
 
662
 
// optional int64 blacklist_timestamp_ms = 2;
663
 
inline bool CacheDiffInfo::has_blacklist_timestamp_ms() const {
664
 
  return (_has_bits_[0] & 0x00000002u) != 0;
665
 
}
666
 
inline void CacheDiffInfo::set_has_blacklist_timestamp_ms() {
667
 
  _has_bits_[0] |= 0x00000002u;
668
 
}
669
 
inline void CacheDiffInfo::clear_has_blacklist_timestamp_ms() {
670
 
  _has_bits_[0] &= ~0x00000002u;
671
 
}
672
 
inline void CacheDiffInfo::clear_blacklist_timestamp_ms() {
673
 
  blacklist_timestamp_ms_ = GOOGLE_LONGLONG(0);
674
 
  clear_has_blacklist_timestamp_ms();
675
 
}
676
 
inline ::google::protobuf::int64 CacheDiffInfo::blacklist_timestamp_ms() const {
677
 
  return blacklist_timestamp_ms_;
678
 
}
679
 
inline void CacheDiffInfo::set_blacklist_timestamp_ms(::google::protobuf::int64 value) {
680
 
  set_has_blacklist_timestamp_ms();
681
 
  blacklist_timestamp_ms_ = value;
682
 
}
683
 
 
684
 
 
685
 
// @@protoc_insertion_point(namespace_scope)
686
 
 
687
 
}  // namespace net_instaweb
688
 
 
689
 
// @@protoc_insertion_point(global_scope)
690
 
 
691
 
#endif  // PROTOBUF_net_2finstaweb_2frewriter_2fcache_5fhtml_5finfo_2eproto__INCLUDED