← 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_css.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_css.pb.h
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
// source: net/instaweb/rewriter/critical_css.proto
3
 
 
4
 
#ifndef PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto__INCLUDED
5
 
#define PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fcss_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_5fcss_2eproto();
32
 
void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
33
 
void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
34
 
 
35
 
class CriticalCssResult;
36
 
class CriticalCssResult_LinkRules;
37
 
 
38
 
// ===================================================================
39
 
 
40
 
class CriticalCssResult_LinkRules : public ::google::protobuf::MessageLite {
41
 
 public:
42
 
  CriticalCssResult_LinkRules();
43
 
  virtual ~CriticalCssResult_LinkRules();
44
 
 
45
 
  CriticalCssResult_LinkRules(const CriticalCssResult_LinkRules& from);
46
 
 
47
 
  inline CriticalCssResult_LinkRules& operator=(const CriticalCssResult_LinkRules& from) {
48
 
    CopyFrom(from);
49
 
    return *this;
50
 
  }
51
 
 
52
 
  static const CriticalCssResult_LinkRules& 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 CriticalCssResult_LinkRules* internal_default_instance() {
60
 
    return default_instance_;
61
 
  }
62
 
  #endif
63
 
 
64
 
  void Swap(CriticalCssResult_LinkRules* other);
65
 
 
66
 
  // implements Message ----------------------------------------------
67
 
 
68
 
  CriticalCssResult_LinkRules* New() const;
69
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
70
 
  void CopyFrom(const CriticalCssResult_LinkRules& from);
71
 
  void MergeFrom(const CriticalCssResult_LinkRules& 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 string link_url = 1;
94
 
  inline bool has_link_url() const;
95
 
  inline void clear_link_url();
96
 
  static const int kLinkUrlFieldNumber = 1;
97
 
  inline const ::std::string& link_url() const;
98
 
  inline void set_link_url(const ::std::string& value);
99
 
  inline void set_link_url(const char* value);
100
 
  inline void set_link_url(const char* value, size_t size);
101
 
  inline ::std::string* mutable_link_url();
102
 
  inline ::std::string* release_link_url();
103
 
  inline void set_allocated_link_url(::std::string* link_url);
104
 
 
105
 
  // optional string critical_rules = 2;
106
 
  inline bool has_critical_rules() const;
107
 
  inline void clear_critical_rules();
108
 
  static const int kCriticalRulesFieldNumber = 2;
109
 
  inline const ::std::string& critical_rules() const;
110
 
  inline void set_critical_rules(const ::std::string& value);
111
 
  inline void set_critical_rules(const char* value);
112
 
  inline void set_critical_rules(const char* value, size_t size);
113
 
  inline ::std::string* mutable_critical_rules();
114
 
  inline ::std::string* release_critical_rules();
115
 
  inline void set_allocated_critical_rules(::std::string* critical_rules);
116
 
 
117
 
  // optional int32 original_size = 3;
118
 
  inline bool has_original_size() const;
119
 
  inline void clear_original_size();
120
 
  static const int kOriginalSizeFieldNumber = 3;
121
 
  inline ::google::protobuf::int32 original_size() const;
122
 
  inline void set_original_size(::google::protobuf::int32 value);
123
 
 
124
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CriticalCssResult.LinkRules)
125
 
 private:
126
 
  inline void set_has_link_url();
127
 
  inline void clear_has_link_url();
128
 
  inline void set_has_critical_rules();
129
 
  inline void clear_has_critical_rules();
130
 
  inline void set_has_original_size();
131
 
  inline void clear_has_original_size();
132
 
 
133
 
  ::std::string* link_url_;
134
 
  ::std::string* critical_rules_;
135
 
  ::google::protobuf::int32 original_size_;
136
 
 
137
 
  mutable int _cached_size_;
138
 
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
139
 
 
140
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
141
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto_impl();
142
 
  #else
143
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
144
 
  #endif
145
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
146
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
147
 
 
148
 
  void InitAsDefaultInstance();
149
 
  static CriticalCssResult_LinkRules* default_instance_;
150
 
};
151
 
// -------------------------------------------------------------------
152
 
 
153
 
class CriticalCssResult : public ::google::protobuf::MessageLite {
154
 
 public:
155
 
  CriticalCssResult();
156
 
  virtual ~CriticalCssResult();
157
 
 
158
 
  CriticalCssResult(const CriticalCssResult& from);
159
 
 
160
 
  inline CriticalCssResult& operator=(const CriticalCssResult& from) {
161
 
    CopyFrom(from);
162
 
    return *this;
163
 
  }
164
 
 
165
 
  static const CriticalCssResult& default_instance();
166
 
 
167
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
168
 
  // Returns the internal default instance pointer. This function can
169
 
  // return NULL thus should not be used by the user. This is intended
170
 
  // for Protobuf internal code. Please use default_instance() declared
171
 
  // above instead.
172
 
  static inline const CriticalCssResult* internal_default_instance() {
173
 
    return default_instance_;
174
 
  }
175
 
  #endif
176
 
 
177
 
  void Swap(CriticalCssResult* other);
178
 
 
179
 
  // implements Message ----------------------------------------------
180
 
 
181
 
  CriticalCssResult* New() const;
182
 
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
183
 
  void CopyFrom(const CriticalCssResult& from);
184
 
  void MergeFrom(const CriticalCssResult& from);
185
 
  void Clear();
186
 
  bool IsInitialized() const;
187
 
 
188
 
  int ByteSize() const;
189
 
  bool MergePartialFromCodedStream(
190
 
      ::google::protobuf::io::CodedInputStream* input);
191
 
  void SerializeWithCachedSizes(
192
 
      ::google::protobuf::io::CodedOutputStream* output) const;
193
 
  int GetCachedSize() const { return _cached_size_; }
194
 
  private:
195
 
  void SharedCtor();
196
 
  void SharedDtor();
197
 
  void SetCachedSize(int size) const;
198
 
  public:
199
 
 
200
 
  ::std::string GetTypeName() const;
201
 
 
202
 
  // nested types ----------------------------------------------------
203
 
 
204
 
  typedef CriticalCssResult_LinkRules LinkRules;
205
 
 
206
 
  // accessors -------------------------------------------------------
207
 
 
208
 
  // repeated .net_instaweb.CriticalCssResult.LinkRules link_rules = 1;
209
 
  inline int link_rules_size() const;
210
 
  inline void clear_link_rules();
211
 
  static const int kLinkRulesFieldNumber = 1;
212
 
  inline const ::net_instaweb::CriticalCssResult_LinkRules& link_rules(int index) const;
213
 
  inline ::net_instaweb::CriticalCssResult_LinkRules* mutable_link_rules(int index);
214
 
  inline ::net_instaweb::CriticalCssResult_LinkRules* add_link_rules();
215
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalCssResult_LinkRules >&
216
 
      link_rules() const;
217
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalCssResult_LinkRules >*
218
 
      mutable_link_rules();
219
 
 
220
 
  // optional int32 exception_count = 2;
221
 
  inline bool has_exception_count() const;
222
 
  inline void clear_exception_count();
223
 
  static const int kExceptionCountFieldNumber = 2;
224
 
  inline ::google::protobuf::int32 exception_count() const;
225
 
  inline void set_exception_count(::google::protobuf::int32 value);
226
 
 
227
 
  // optional int32 import_count = 3;
228
 
  inline bool has_import_count() const;
229
 
  inline void clear_import_count();
230
 
  static const int kImportCountFieldNumber = 3;
231
 
  inline ::google::protobuf::int32 import_count() const;
232
 
  inline void set_import_count(::google::protobuf::int32 value);
233
 
 
234
 
  // optional int32 link_count = 4;
235
 
  inline bool has_link_count() const;
236
 
  inline void clear_link_count();
237
 
  static const int kLinkCountFieldNumber = 4;
238
 
  inline ::google::protobuf::int32 link_count() const;
239
 
  inline void set_link_count(::google::protobuf::int32 value);
240
 
 
241
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CriticalCssResult)
242
 
 private:
243
 
  inline void set_has_exception_count();
244
 
  inline void clear_has_exception_count();
245
 
  inline void set_has_import_count();
246
 
  inline void clear_has_import_count();
247
 
  inline void set_has_link_count();
248
 
  inline void clear_has_link_count();
249
 
 
250
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalCssResult_LinkRules > link_rules_;
251
 
  ::google::protobuf::int32 exception_count_;
252
 
  ::google::protobuf::int32 import_count_;
253
 
  ::google::protobuf::int32 link_count_;
254
 
 
255
 
  mutable int _cached_size_;
256
 
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
257
 
 
258
 
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
259
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto_impl();
260
 
  #else
261
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
262
 
  #endif
263
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
264
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto();
265
 
 
266
 
  void InitAsDefaultInstance();
267
 
  static CriticalCssResult* default_instance_;
268
 
};
269
 
// ===================================================================
270
 
 
271
 
 
272
 
// ===================================================================
273
 
 
274
 
// CriticalCssResult_LinkRules
275
 
 
276
 
// optional string link_url = 1;
277
 
inline bool CriticalCssResult_LinkRules::has_link_url() const {
278
 
  return (_has_bits_[0] & 0x00000001u) != 0;
279
 
}
280
 
inline void CriticalCssResult_LinkRules::set_has_link_url() {
281
 
  _has_bits_[0] |= 0x00000001u;
282
 
}
283
 
inline void CriticalCssResult_LinkRules::clear_has_link_url() {
284
 
  _has_bits_[0] &= ~0x00000001u;
285
 
}
286
 
inline void CriticalCssResult_LinkRules::clear_link_url() {
287
 
  if (link_url_ != &::google::protobuf::internal::GetEmptyString()) {
288
 
    link_url_->clear();
289
 
  }
290
 
  clear_has_link_url();
291
 
}
292
 
inline const ::std::string& CriticalCssResult_LinkRules::link_url() const {
293
 
  return *link_url_;
294
 
}
295
 
inline void CriticalCssResult_LinkRules::set_link_url(const ::std::string& value) {
296
 
  set_has_link_url();
297
 
  if (link_url_ == &::google::protobuf::internal::GetEmptyString()) {
298
 
    link_url_ = new ::std::string;
299
 
  }
300
 
  link_url_->assign(value);
301
 
}
302
 
inline void CriticalCssResult_LinkRules::set_link_url(const char* value) {
303
 
  set_has_link_url();
304
 
  if (link_url_ == &::google::protobuf::internal::GetEmptyString()) {
305
 
    link_url_ = new ::std::string;
306
 
  }
307
 
  link_url_->assign(value);
308
 
}
309
 
inline void CriticalCssResult_LinkRules::set_link_url(const char* value, size_t size) {
310
 
  set_has_link_url();
311
 
  if (link_url_ == &::google::protobuf::internal::GetEmptyString()) {
312
 
    link_url_ = new ::std::string;
313
 
  }
314
 
  link_url_->assign(reinterpret_cast<const char*>(value), size);
315
 
}
316
 
inline ::std::string* CriticalCssResult_LinkRules::mutable_link_url() {
317
 
  set_has_link_url();
318
 
  if (link_url_ == &::google::protobuf::internal::GetEmptyString()) {
319
 
    link_url_ = new ::std::string;
320
 
  }
321
 
  return link_url_;
322
 
}
323
 
inline ::std::string* CriticalCssResult_LinkRules::release_link_url() {
324
 
  clear_has_link_url();
325
 
  if (link_url_ == &::google::protobuf::internal::GetEmptyString()) {
326
 
    return NULL;
327
 
  } else {
328
 
    ::std::string* temp = link_url_;
329
 
    link_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
330
 
    return temp;
331
 
  }
332
 
}
333
 
inline void CriticalCssResult_LinkRules::set_allocated_link_url(::std::string* link_url) {
334
 
  if (link_url_ != &::google::protobuf::internal::GetEmptyString()) {
335
 
    delete link_url_;
336
 
  }
337
 
  if (link_url) {
338
 
    set_has_link_url();
339
 
    link_url_ = link_url;
340
 
  } else {
341
 
    clear_has_link_url();
342
 
    link_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
343
 
  }
344
 
}
345
 
 
346
 
// optional string critical_rules = 2;
347
 
inline bool CriticalCssResult_LinkRules::has_critical_rules() const {
348
 
  return (_has_bits_[0] & 0x00000002u) != 0;
349
 
}
350
 
inline void CriticalCssResult_LinkRules::set_has_critical_rules() {
351
 
  _has_bits_[0] |= 0x00000002u;
352
 
}
353
 
inline void CriticalCssResult_LinkRules::clear_has_critical_rules() {
354
 
  _has_bits_[0] &= ~0x00000002u;
355
 
}
356
 
inline void CriticalCssResult_LinkRules::clear_critical_rules() {
357
 
  if (critical_rules_ != &::google::protobuf::internal::GetEmptyString()) {
358
 
    critical_rules_->clear();
359
 
  }
360
 
  clear_has_critical_rules();
361
 
}
362
 
inline const ::std::string& CriticalCssResult_LinkRules::critical_rules() const {
363
 
  return *critical_rules_;
364
 
}
365
 
inline void CriticalCssResult_LinkRules::set_critical_rules(const ::std::string& value) {
366
 
  set_has_critical_rules();
367
 
  if (critical_rules_ == &::google::protobuf::internal::GetEmptyString()) {
368
 
    critical_rules_ = new ::std::string;
369
 
  }
370
 
  critical_rules_->assign(value);
371
 
}
372
 
inline void CriticalCssResult_LinkRules::set_critical_rules(const char* value) {
373
 
  set_has_critical_rules();
374
 
  if (critical_rules_ == &::google::protobuf::internal::GetEmptyString()) {
375
 
    critical_rules_ = new ::std::string;
376
 
  }
377
 
  critical_rules_->assign(value);
378
 
}
379
 
inline void CriticalCssResult_LinkRules::set_critical_rules(const char* value, size_t size) {
380
 
  set_has_critical_rules();
381
 
  if (critical_rules_ == &::google::protobuf::internal::GetEmptyString()) {
382
 
    critical_rules_ = new ::std::string;
383
 
  }
384
 
  critical_rules_->assign(reinterpret_cast<const char*>(value), size);
385
 
}
386
 
inline ::std::string* CriticalCssResult_LinkRules::mutable_critical_rules() {
387
 
  set_has_critical_rules();
388
 
  if (critical_rules_ == &::google::protobuf::internal::GetEmptyString()) {
389
 
    critical_rules_ = new ::std::string;
390
 
  }
391
 
  return critical_rules_;
392
 
}
393
 
inline ::std::string* CriticalCssResult_LinkRules::release_critical_rules() {
394
 
  clear_has_critical_rules();
395
 
  if (critical_rules_ == &::google::protobuf::internal::GetEmptyString()) {
396
 
    return NULL;
397
 
  } else {
398
 
    ::std::string* temp = critical_rules_;
399
 
    critical_rules_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
400
 
    return temp;
401
 
  }
402
 
}
403
 
inline void CriticalCssResult_LinkRules::set_allocated_critical_rules(::std::string* critical_rules) {
404
 
  if (critical_rules_ != &::google::protobuf::internal::GetEmptyString()) {
405
 
    delete critical_rules_;
406
 
  }
407
 
  if (critical_rules) {
408
 
    set_has_critical_rules();
409
 
    critical_rules_ = critical_rules;
410
 
  } else {
411
 
    clear_has_critical_rules();
412
 
    critical_rules_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
413
 
  }
414
 
}
415
 
 
416
 
// optional int32 original_size = 3;
417
 
inline bool CriticalCssResult_LinkRules::has_original_size() const {
418
 
  return (_has_bits_[0] & 0x00000004u) != 0;
419
 
}
420
 
inline void CriticalCssResult_LinkRules::set_has_original_size() {
421
 
  _has_bits_[0] |= 0x00000004u;
422
 
}
423
 
inline void CriticalCssResult_LinkRules::clear_has_original_size() {
424
 
  _has_bits_[0] &= ~0x00000004u;
425
 
}
426
 
inline void CriticalCssResult_LinkRules::clear_original_size() {
427
 
  original_size_ = 0;
428
 
  clear_has_original_size();
429
 
}
430
 
inline ::google::protobuf::int32 CriticalCssResult_LinkRules::original_size() const {
431
 
  return original_size_;
432
 
}
433
 
inline void CriticalCssResult_LinkRules::set_original_size(::google::protobuf::int32 value) {
434
 
  set_has_original_size();
435
 
  original_size_ = value;
436
 
}
437
 
 
438
 
// -------------------------------------------------------------------
439
 
 
440
 
// CriticalCssResult
441
 
 
442
 
// repeated .net_instaweb.CriticalCssResult.LinkRules link_rules = 1;
443
 
inline int CriticalCssResult::link_rules_size() const {
444
 
  return link_rules_.size();
445
 
}
446
 
inline void CriticalCssResult::clear_link_rules() {
447
 
  link_rules_.Clear();
448
 
}
449
 
inline const ::net_instaweb::CriticalCssResult_LinkRules& CriticalCssResult::link_rules(int index) const {
450
 
  return link_rules_.Get(index);
451
 
}
452
 
inline ::net_instaweb::CriticalCssResult_LinkRules* CriticalCssResult::mutable_link_rules(int index) {
453
 
  return link_rules_.Mutable(index);
454
 
}
455
 
inline ::net_instaweb::CriticalCssResult_LinkRules* CriticalCssResult::add_link_rules() {
456
 
  return link_rules_.Add();
457
 
}
458
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalCssResult_LinkRules >&
459
 
CriticalCssResult::link_rules() const {
460
 
  return link_rules_;
461
 
}
462
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CriticalCssResult_LinkRules >*
463
 
CriticalCssResult::mutable_link_rules() {
464
 
  return &link_rules_;
465
 
}
466
 
 
467
 
// optional int32 exception_count = 2;
468
 
inline bool CriticalCssResult::has_exception_count() const {
469
 
  return (_has_bits_[0] & 0x00000002u) != 0;
470
 
}
471
 
inline void CriticalCssResult::set_has_exception_count() {
472
 
  _has_bits_[0] |= 0x00000002u;
473
 
}
474
 
inline void CriticalCssResult::clear_has_exception_count() {
475
 
  _has_bits_[0] &= ~0x00000002u;
476
 
}
477
 
inline void CriticalCssResult::clear_exception_count() {
478
 
  exception_count_ = 0;
479
 
  clear_has_exception_count();
480
 
}
481
 
inline ::google::protobuf::int32 CriticalCssResult::exception_count() const {
482
 
  return exception_count_;
483
 
}
484
 
inline void CriticalCssResult::set_exception_count(::google::protobuf::int32 value) {
485
 
  set_has_exception_count();
486
 
  exception_count_ = value;
487
 
}
488
 
 
489
 
// optional int32 import_count = 3;
490
 
inline bool CriticalCssResult::has_import_count() const {
491
 
  return (_has_bits_[0] & 0x00000004u) != 0;
492
 
}
493
 
inline void CriticalCssResult::set_has_import_count() {
494
 
  _has_bits_[0] |= 0x00000004u;
495
 
}
496
 
inline void CriticalCssResult::clear_has_import_count() {
497
 
  _has_bits_[0] &= ~0x00000004u;
498
 
}
499
 
inline void CriticalCssResult::clear_import_count() {
500
 
  import_count_ = 0;
501
 
  clear_has_import_count();
502
 
}
503
 
inline ::google::protobuf::int32 CriticalCssResult::import_count() const {
504
 
  return import_count_;
505
 
}
506
 
inline void CriticalCssResult::set_import_count(::google::protobuf::int32 value) {
507
 
  set_has_import_count();
508
 
  import_count_ = value;
509
 
}
510
 
 
511
 
// optional int32 link_count = 4;
512
 
inline bool CriticalCssResult::has_link_count() const {
513
 
  return (_has_bits_[0] & 0x00000008u) != 0;
514
 
}
515
 
inline void CriticalCssResult::set_has_link_count() {
516
 
  _has_bits_[0] |= 0x00000008u;
517
 
}
518
 
inline void CriticalCssResult::clear_has_link_count() {
519
 
  _has_bits_[0] &= ~0x00000008u;
520
 
}
521
 
inline void CriticalCssResult::clear_link_count() {
522
 
  link_count_ = 0;
523
 
  clear_has_link_count();
524
 
}
525
 
inline ::google::protobuf::int32 CriticalCssResult::link_count() const {
526
 
  return link_count_;
527
 
}
528
 
inline void CriticalCssResult::set_link_count(::google::protobuf::int32 value) {
529
 
  set_has_link_count();
530
 
  link_count_ = value;
531
 
}
532
 
 
533
 
 
534
 
// @@protoc_insertion_point(namespace_scope)
535
 
 
536
 
}  // namespace net_instaweb
537
 
 
538
 
// @@protoc_insertion_point(global_scope)
539
 
 
540
 
#endif  // PROTOBUF_net_2finstaweb_2frewriter_2fcritical_5fcss_2eproto__INCLUDED