← 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/Release/obj/gen/protoc_out/instaweb/net/instaweb/rewriter/cached_result.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/Release/obj/gen/protoc_out/instaweb/net/instaweb/rewriter/cached_result.pb.h
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
// source: net/instaweb/rewriter/cached_result.proto
3
 
 
4
 
#ifndef PROTOBUF_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto__INCLUDED
5
 
#define PROTOBUF_net_2finstaweb_2frewriter_2fcached_5fresult_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.h>
24
 
#include <google/protobuf/repeated_field.h>
25
 
#include <google/protobuf/extension_set.h>
26
 
#include <google/protobuf/unknown_field_set.h>
27
 
#include <google/protobuf/generated_enum_reflection.h>
28
 
#include <google/protobuf/unknown_field_set.h>
29
 
#include "net/instaweb/spriter/public/image_spriter.pb.h"
30
 
// @@protoc_insertion_point(includes)
31
 
 
32
 
namespace net_instaweb {
33
 
 
34
 
// Internal implementation detail -- do not call these.
35
 
void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
36
 
void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
37
 
void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
38
 
 
39
 
class ImageDim;
40
 
class InputInfo;
41
 
class CachedResult;
42
 
class OutputPartitions;
43
 
class ResourceContext;
44
 
 
45
 
enum InputInfo_Type {
46
 
  InputInfo_Type_CACHED = 1,
47
 
  InputInfo_Type_FILE_BASED = 2,
48
 
  InputInfo_Type_ALWAYS_VALID = 3
49
 
};
50
 
bool InputInfo_Type_IsValid(int value);
51
 
const InputInfo_Type InputInfo_Type_Type_MIN = InputInfo_Type_CACHED;
52
 
const InputInfo_Type InputInfo_Type_Type_MAX = InputInfo_Type_ALWAYS_VALID;
53
 
const int InputInfo_Type_Type_ARRAYSIZE = InputInfo_Type_Type_MAX + 1;
54
 
 
55
 
const ::google::protobuf::EnumDescriptor* InputInfo_Type_descriptor();
56
 
inline const ::std::string& InputInfo_Type_Name(InputInfo_Type value) {
57
 
  return ::google::protobuf::internal::NameOfEnum(
58
 
    InputInfo_Type_descriptor(), value);
59
 
}
60
 
inline bool InputInfo_Type_Parse(
61
 
    const ::std::string& name, InputInfo_Type* value) {
62
 
  return ::google::protobuf::internal::ParseNamedEnum<InputInfo_Type>(
63
 
    InputInfo_Type_descriptor(), name, value);
64
 
}
65
 
enum ResourceContext_LibWebpLevel {
66
 
  ResourceContext_LibWebpLevel_LIBWEBP_NONE = 0,
67
 
  ResourceContext_LibWebpLevel_LIBWEBP_LOSSY_ONLY = 1,
68
 
  ResourceContext_LibWebpLevel_LIBWEBP_LOSSY_LOSSLESS_ALPHA = 2
69
 
};
70
 
bool ResourceContext_LibWebpLevel_IsValid(int value);
71
 
const ResourceContext_LibWebpLevel ResourceContext_LibWebpLevel_LibWebpLevel_MIN = ResourceContext_LibWebpLevel_LIBWEBP_NONE;
72
 
const ResourceContext_LibWebpLevel ResourceContext_LibWebpLevel_LibWebpLevel_MAX = ResourceContext_LibWebpLevel_LIBWEBP_LOSSY_LOSSLESS_ALPHA;
73
 
const int ResourceContext_LibWebpLevel_LibWebpLevel_ARRAYSIZE = ResourceContext_LibWebpLevel_LibWebpLevel_MAX + 1;
74
 
 
75
 
const ::google::protobuf::EnumDescriptor* ResourceContext_LibWebpLevel_descriptor();
76
 
inline const ::std::string& ResourceContext_LibWebpLevel_Name(ResourceContext_LibWebpLevel value) {
77
 
  return ::google::protobuf::internal::NameOfEnum(
78
 
    ResourceContext_LibWebpLevel_descriptor(), value);
79
 
}
80
 
inline bool ResourceContext_LibWebpLevel_Parse(
81
 
    const ::std::string& name, ResourceContext_LibWebpLevel* value) {
82
 
  return ::google::protobuf::internal::ParseNamedEnum<ResourceContext_LibWebpLevel>(
83
 
    ResourceContext_LibWebpLevel_descriptor(), name, value);
84
 
}
85
 
// ===================================================================
86
 
 
87
 
class ImageDim : public ::google::protobuf::Message {
88
 
 public:
89
 
  ImageDim();
90
 
  virtual ~ImageDim();
91
 
 
92
 
  ImageDim(const ImageDim& from);
93
 
 
94
 
  inline ImageDim& operator=(const ImageDim& from) {
95
 
    CopyFrom(from);
96
 
    return *this;
97
 
  }
98
 
 
99
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
100
 
    return _unknown_fields_;
101
 
  }
102
 
 
103
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
104
 
    return &_unknown_fields_;
105
 
  }
106
 
 
107
 
  static const ::google::protobuf::Descriptor* descriptor();
108
 
  static const ImageDim& default_instance();
109
 
 
110
 
  void Swap(ImageDim* other);
111
 
 
112
 
  // implements Message ----------------------------------------------
113
 
 
114
 
  ImageDim* New() const;
115
 
  void CopyFrom(const ::google::protobuf::Message& from);
116
 
  void MergeFrom(const ::google::protobuf::Message& from);
117
 
  void CopyFrom(const ImageDim& from);
118
 
  void MergeFrom(const ImageDim& from);
119
 
  void Clear();
120
 
  bool IsInitialized() const;
121
 
 
122
 
  int ByteSize() const;
123
 
  bool MergePartialFromCodedStream(
124
 
      ::google::protobuf::io::CodedInputStream* input);
125
 
  void SerializeWithCachedSizes(
126
 
      ::google::protobuf::io::CodedOutputStream* output) const;
127
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
128
 
  int GetCachedSize() const { return _cached_size_; }
129
 
  private:
130
 
  void SharedCtor();
131
 
  void SharedDtor();
132
 
  void SetCachedSize(int size) const;
133
 
  public:
134
 
 
135
 
  ::google::protobuf::Metadata GetMetadata() const;
136
 
 
137
 
  // nested types ----------------------------------------------------
138
 
 
139
 
  // accessors -------------------------------------------------------
140
 
 
141
 
  // optional int32 width = 1 [default = -1];
142
 
  inline bool has_width() const;
143
 
  inline void clear_width();
144
 
  static const int kWidthFieldNumber = 1;
145
 
  inline ::google::protobuf::int32 width() const;
146
 
  inline void set_width(::google::protobuf::int32 value);
147
 
 
148
 
  // optional int32 height = 2 [default = -1];
149
 
  inline bool has_height() const;
150
 
  inline void clear_height();
151
 
  static const int kHeightFieldNumber = 2;
152
 
  inline ::google::protobuf::int32 height() const;
153
 
  inline void set_height(::google::protobuf::int32 value);
154
 
 
155
 
  // @@protoc_insertion_point(class_scope:net_instaweb.ImageDim)
156
 
 private:
157
 
  inline void set_has_width();
158
 
  inline void clear_has_width();
159
 
  inline void set_has_height();
160
 
  inline void clear_has_height();
161
 
 
162
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
163
 
 
164
 
  ::google::protobuf::int32 width_;
165
 
  ::google::protobuf::int32 height_;
166
 
 
167
 
  mutable int _cached_size_;
168
 
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
169
 
 
170
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
171
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
172
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
173
 
 
174
 
  void InitAsDefaultInstance();
175
 
  static ImageDim* default_instance_;
176
 
};
177
 
// -------------------------------------------------------------------
178
 
 
179
 
class InputInfo : public ::google::protobuf::Message {
180
 
 public:
181
 
  InputInfo();
182
 
  virtual ~InputInfo();
183
 
 
184
 
  InputInfo(const InputInfo& from);
185
 
 
186
 
  inline InputInfo& operator=(const InputInfo& from) {
187
 
    CopyFrom(from);
188
 
    return *this;
189
 
  }
190
 
 
191
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
192
 
    return _unknown_fields_;
193
 
  }
194
 
 
195
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
196
 
    return &_unknown_fields_;
197
 
  }
198
 
 
199
 
  static const ::google::protobuf::Descriptor* descriptor();
200
 
  static const InputInfo& default_instance();
201
 
 
202
 
  void Swap(InputInfo* other);
203
 
 
204
 
  // implements Message ----------------------------------------------
205
 
 
206
 
  InputInfo* New() const;
207
 
  void CopyFrom(const ::google::protobuf::Message& from);
208
 
  void MergeFrom(const ::google::protobuf::Message& from);
209
 
  void CopyFrom(const InputInfo& from);
210
 
  void MergeFrom(const InputInfo& from);
211
 
  void Clear();
212
 
  bool IsInitialized() const;
213
 
 
214
 
  int ByteSize() const;
215
 
  bool MergePartialFromCodedStream(
216
 
      ::google::protobuf::io::CodedInputStream* input);
217
 
  void SerializeWithCachedSizes(
218
 
      ::google::protobuf::io::CodedOutputStream* output) const;
219
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
220
 
  int GetCachedSize() const { return _cached_size_; }
221
 
  private:
222
 
  void SharedCtor();
223
 
  void SharedDtor();
224
 
  void SetCachedSize(int size) const;
225
 
  public:
226
 
 
227
 
  ::google::protobuf::Metadata GetMetadata() const;
228
 
 
229
 
  // nested types ----------------------------------------------------
230
 
 
231
 
  typedef InputInfo_Type Type;
232
 
  static const Type CACHED = InputInfo_Type_CACHED;
233
 
  static const Type FILE_BASED = InputInfo_Type_FILE_BASED;
234
 
  static const Type ALWAYS_VALID = InputInfo_Type_ALWAYS_VALID;
235
 
  static inline bool Type_IsValid(int value) {
236
 
    return InputInfo_Type_IsValid(value);
237
 
  }
238
 
  static const Type Type_MIN =
239
 
    InputInfo_Type_Type_MIN;
240
 
  static const Type Type_MAX =
241
 
    InputInfo_Type_Type_MAX;
242
 
  static const int Type_ARRAYSIZE =
243
 
    InputInfo_Type_Type_ARRAYSIZE;
244
 
  static inline const ::google::protobuf::EnumDescriptor*
245
 
  Type_descriptor() {
246
 
    return InputInfo_Type_descriptor();
247
 
  }
248
 
  static inline const ::std::string& Type_Name(Type value) {
249
 
    return InputInfo_Type_Name(value);
250
 
  }
251
 
  static inline bool Type_Parse(const ::std::string& name,
252
 
      Type* value) {
253
 
    return InputInfo_Type_Parse(name, value);
254
 
  }
255
 
 
256
 
  // accessors -------------------------------------------------------
257
 
 
258
 
  // optional int32 index = 1;
259
 
  inline bool has_index() const;
260
 
  inline void clear_index();
261
 
  static const int kIndexFieldNumber = 1;
262
 
  inline ::google::protobuf::int32 index() const;
263
 
  inline void set_index(::google::protobuf::int32 value);
264
 
 
265
 
  // required .net_instaweb.InputInfo.Type type = 2;
266
 
  inline bool has_type() const;
267
 
  inline void clear_type();
268
 
  static const int kTypeFieldNumber = 2;
269
 
  inline ::net_instaweb::InputInfo_Type type() const;
270
 
  inline void set_type(::net_instaweb::InputInfo_Type value);
271
 
 
272
 
  // optional int64 last_modified_time_ms = 3;
273
 
  inline bool has_last_modified_time_ms() const;
274
 
  inline void clear_last_modified_time_ms();
275
 
  static const int kLastModifiedTimeMsFieldNumber = 3;
276
 
  inline ::google::protobuf::int64 last_modified_time_ms() const;
277
 
  inline void set_last_modified_time_ms(::google::protobuf::int64 value);
278
 
 
279
 
  // optional int64 expiration_time_ms = 4;
280
 
  inline bool has_expiration_time_ms() const;
281
 
  inline void clear_expiration_time_ms();
282
 
  static const int kExpirationTimeMsFieldNumber = 4;
283
 
  inline ::google::protobuf::int64 expiration_time_ms() const;
284
 
  inline void set_expiration_time_ms(::google::protobuf::int64 value);
285
 
 
286
 
  // optional string filename = 5;
287
 
  inline bool has_filename() const;
288
 
  inline void clear_filename();
289
 
  static const int kFilenameFieldNumber = 5;
290
 
  inline const ::std::string& filename() const;
291
 
  inline void set_filename(const ::std::string& value);
292
 
  inline void set_filename(const char* value);
293
 
  inline void set_filename(const char* value, size_t size);
294
 
  inline ::std::string* mutable_filename();
295
 
  inline ::std::string* release_filename();
296
 
  inline void set_allocated_filename(::std::string* filename);
297
 
 
298
 
  // optional int64 date_ms = 6;
299
 
  inline bool has_date_ms() const;
300
 
  inline void clear_date_ms();
301
 
  static const int kDateMsFieldNumber = 6;
302
 
  inline ::google::protobuf::int64 date_ms() const;
303
 
  inline void set_date_ms(::google::protobuf::int64 value);
304
 
 
305
 
  // optional string input_content_hash = 7;
306
 
  inline bool has_input_content_hash() const;
307
 
  inline void clear_input_content_hash();
308
 
  static const int kInputContentHashFieldNumber = 7;
309
 
  inline const ::std::string& input_content_hash() const;
310
 
  inline void set_input_content_hash(const ::std::string& value);
311
 
  inline void set_input_content_hash(const char* value);
312
 
  inline void set_input_content_hash(const char* value, size_t size);
313
 
  inline ::std::string* mutable_input_content_hash();
314
 
  inline ::std::string* release_input_content_hash();
315
 
  inline void set_allocated_input_content_hash(::std::string* input_content_hash);
316
 
 
317
 
  // optional bool disable_further_processing = 8 [default = false];
318
 
  inline bool has_disable_further_processing() const;
319
 
  inline void clear_disable_further_processing();
320
 
  static const int kDisableFurtherProcessingFieldNumber = 8;
321
 
  inline bool disable_further_processing() const;
322
 
  inline void set_disable_further_processing(bool value);
323
 
 
324
 
  // optional string url = 9;
325
 
  inline bool has_url() const;
326
 
  inline void clear_url();
327
 
  static const int kUrlFieldNumber = 9;
328
 
  inline const ::std::string& url() const;
329
 
  inline void set_url(const ::std::string& value);
330
 
  inline void set_url(const char* value);
331
 
  inline void set_url(const char* value, size_t size);
332
 
  inline ::std::string* mutable_url();
333
 
  inline ::std::string* release_url();
334
 
  inline void set_allocated_url(::std::string* url);
335
 
 
336
 
  // @@protoc_insertion_point(class_scope:net_instaweb.InputInfo)
337
 
 private:
338
 
  inline void set_has_index();
339
 
  inline void clear_has_index();
340
 
  inline void set_has_type();
341
 
  inline void clear_has_type();
342
 
  inline void set_has_last_modified_time_ms();
343
 
  inline void clear_has_last_modified_time_ms();
344
 
  inline void set_has_expiration_time_ms();
345
 
  inline void clear_has_expiration_time_ms();
346
 
  inline void set_has_filename();
347
 
  inline void clear_has_filename();
348
 
  inline void set_has_date_ms();
349
 
  inline void clear_has_date_ms();
350
 
  inline void set_has_input_content_hash();
351
 
  inline void clear_has_input_content_hash();
352
 
  inline void set_has_disable_further_processing();
353
 
  inline void clear_has_disable_further_processing();
354
 
  inline void set_has_url();
355
 
  inline void clear_has_url();
356
 
 
357
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
358
 
 
359
 
  ::google::protobuf::int32 index_;
360
 
  int type_;
361
 
  ::google::protobuf::int64 last_modified_time_ms_;
362
 
  ::google::protobuf::int64 expiration_time_ms_;
363
 
  ::std::string* filename_;
364
 
  ::google::protobuf::int64 date_ms_;
365
 
  ::std::string* input_content_hash_;
366
 
  ::std::string* url_;
367
 
  bool disable_further_processing_;
368
 
 
369
 
  mutable int _cached_size_;
370
 
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
371
 
 
372
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
373
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
374
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
375
 
 
376
 
  void InitAsDefaultInstance();
377
 
  static InputInfo* default_instance_;
378
 
};
379
 
// -------------------------------------------------------------------
380
 
 
381
 
class CachedResult : public ::google::protobuf::Message {
382
 
 public:
383
 
  CachedResult();
384
 
  virtual ~CachedResult();
385
 
 
386
 
  CachedResult(const CachedResult& from);
387
 
 
388
 
  inline CachedResult& operator=(const CachedResult& from) {
389
 
    CopyFrom(from);
390
 
    return *this;
391
 
  }
392
 
 
393
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
394
 
    return _unknown_fields_;
395
 
  }
396
 
 
397
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
398
 
    return &_unknown_fields_;
399
 
  }
400
 
 
401
 
  static const ::google::protobuf::Descriptor* descriptor();
402
 
  static const CachedResult& default_instance();
403
 
 
404
 
  void Swap(CachedResult* other);
405
 
 
406
 
  // implements Message ----------------------------------------------
407
 
 
408
 
  CachedResult* New() const;
409
 
  void CopyFrom(const ::google::protobuf::Message& from);
410
 
  void MergeFrom(const ::google::protobuf::Message& from);
411
 
  void CopyFrom(const CachedResult& from);
412
 
  void MergeFrom(const CachedResult& from);
413
 
  void Clear();
414
 
  bool IsInitialized() const;
415
 
 
416
 
  int ByteSize() const;
417
 
  bool MergePartialFromCodedStream(
418
 
      ::google::protobuf::io::CodedInputStream* input);
419
 
  void SerializeWithCachedSizes(
420
 
      ::google::protobuf::io::CodedOutputStream* output) const;
421
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
422
 
  int GetCachedSize() const { return _cached_size_; }
423
 
  private:
424
 
  void SharedCtor();
425
 
  void SharedDtor();
426
 
  void SetCachedSize(int size) const;
427
 
  public:
428
 
 
429
 
  ::google::protobuf::Metadata GetMetadata() const;
430
 
 
431
 
  // nested types ----------------------------------------------------
432
 
 
433
 
  // accessors -------------------------------------------------------
434
 
 
435
 
  // optional bool optimizable = 1 [default = true];
436
 
  inline bool has_optimizable() const;
437
 
  inline void clear_optimizable();
438
 
  static const int kOptimizableFieldNumber = 1;
439
 
  inline bool optimizable() const;
440
 
  inline void set_optimizable(bool value);
441
 
 
442
 
  // optional string url = 2;
443
 
  inline bool has_url() const;
444
 
  inline void clear_url();
445
 
  static const int kUrlFieldNumber = 2;
446
 
  inline const ::std::string& url() const;
447
 
  inline void set_url(const ::std::string& value);
448
 
  inline void set_url(const char* value);
449
 
  inline void set_url(const char* value, size_t size);
450
 
  inline ::std::string* mutable_url();
451
 
  inline ::std::string* release_url();
452
 
  inline void set_allocated_url(::std::string* url);
453
 
 
454
 
  // optional bool frozen = 5 [default = false];
455
 
  inline bool has_frozen() const;
456
 
  inline void clear_frozen();
457
 
  static const int kFrozenFieldNumber = 5;
458
 
  inline bool frozen() const;
459
 
  inline void set_frozen(bool value);
460
 
 
461
 
  // optional string hash = 6;
462
 
  inline bool has_hash() const;
463
 
  inline void clear_hash();
464
 
  static const int kHashFieldNumber = 6;
465
 
  inline const ::std::string& hash() const;
466
 
  inline void set_hash(const ::std::string& value);
467
 
  inline void set_hash(const char* value);
468
 
  inline void set_hash(const char* value, size_t size);
469
 
  inline ::std::string* mutable_hash();
470
 
  inline ::std::string* release_hash();
471
 
  inline void set_allocated_hash(::std::string* hash);
472
 
 
473
 
  // optional string extension = 7;
474
 
  inline bool has_extension() const;
475
 
  inline void clear_extension();
476
 
  static const int kExtensionFieldNumber = 7;
477
 
  inline const ::std::string& extension() const;
478
 
  inline void set_extension(const ::std::string& value);
479
 
  inline void set_extension(const char* value);
480
 
  inline void set_extension(const char* value, size_t size);
481
 
  inline ::std::string* mutable_extension();
482
 
  inline ::std::string* release_extension();
483
 
  inline void set_allocated_extension(::std::string* extension);
484
 
 
485
 
  // optional .net_instaweb.ImageDim image_file_dims = 11;
486
 
  inline bool has_image_file_dims() const;
487
 
  inline void clear_image_file_dims();
488
 
  static const int kImageFileDimsFieldNumber = 11;
489
 
  inline const ::net_instaweb::ImageDim& image_file_dims() const;
490
 
  inline ::net_instaweb::ImageDim* mutable_image_file_dims();
491
 
  inline ::net_instaweb::ImageDim* release_image_file_dims();
492
 
  inline void set_allocated_image_file_dims(::net_instaweb::ImageDim* image_file_dims);
493
 
 
494
 
  // optional bytes inlined_data = 12;
495
 
  inline bool has_inlined_data() const;
496
 
  inline void clear_inlined_data();
497
 
  static const int kInlinedDataFieldNumber = 12;
498
 
  inline const ::std::string& inlined_data() const;
499
 
  inline void set_inlined_data(const ::std::string& value);
500
 
  inline void set_inlined_data(const char* value);
501
 
  inline void set_inlined_data(const void* value, size_t size);
502
 
  inline ::std::string* mutable_inlined_data();
503
 
  inline ::std::string* release_inlined_data();
504
 
  inline void set_allocated_inlined_data(::std::string* inlined_data);
505
 
 
506
 
  // optional .net_instaweb.spriter.SpriterResult spriter_result = 13;
507
 
  inline bool has_spriter_result() const;
508
 
  inline void clear_spriter_result();
509
 
  static const int kSpriterResultFieldNumber = 13;
510
 
  inline const ::net_instaweb::spriter::SpriterResult& spriter_result() const;
511
 
  inline ::net_instaweb::spriter::SpriterResult* mutable_spriter_result();
512
 
  inline ::net_instaweb::spriter::SpriterResult* release_spriter_result();
513
 
  inline void set_allocated_spriter_result(::net_instaweb::spriter::SpriterResult* spriter_result);
514
 
 
515
 
  // repeated .net_instaweb.InputInfo input = 14;
516
 
  inline int input_size() const;
517
 
  inline void clear_input();
518
 
  static const int kInputFieldNumber = 14;
519
 
  inline const ::net_instaweb::InputInfo& input(int index) const;
520
 
  inline ::net_instaweb::InputInfo* mutable_input(int index);
521
 
  inline ::net_instaweb::InputInfo* add_input();
522
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >&
523
 
      input() const;
524
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >*
525
 
      mutable_input();
526
 
 
527
 
  // optional int32 inlined_image_type = 15;
528
 
  inline bool has_inlined_image_type() const;
529
 
  inline void clear_inlined_image_type();
530
 
  static const int kInlinedImageTypeFieldNumber = 15;
531
 
  inline ::google::protobuf::int32 inlined_image_type() const;
532
 
  inline void set_inlined_image_type(::google::protobuf::int32 value);
533
 
 
534
 
  // optional bytes low_resolution_inlined_data = 16;
535
 
  inline bool has_low_resolution_inlined_data() const;
536
 
  inline void clear_low_resolution_inlined_data();
537
 
  static const int kLowResolutionInlinedDataFieldNumber = 16;
538
 
  inline const ::std::string& low_resolution_inlined_data() const;
539
 
  inline void set_low_resolution_inlined_data(const ::std::string& value);
540
 
  inline void set_low_resolution_inlined_data(const char* value);
541
 
  inline void set_low_resolution_inlined_data(const void* value, size_t size);
542
 
  inline ::std::string* mutable_low_resolution_inlined_data();
543
 
  inline ::std::string* release_low_resolution_inlined_data();
544
 
  inline void set_allocated_low_resolution_inlined_data(::std::string* low_resolution_inlined_data);
545
 
 
546
 
  // optional int32 low_resolution_inlined_image_type = 17;
547
 
  inline bool has_low_resolution_inlined_image_type() const;
548
 
  inline void clear_low_resolution_inlined_image_type();
549
 
  static const int kLowResolutionInlinedImageTypeFieldNumber = 17;
550
 
  inline ::google::protobuf::int32 low_resolution_inlined_image_type() const;
551
 
  inline void set_low_resolution_inlined_image_type(::google::protobuf::int32 value);
552
 
 
553
 
  // optional bool url_relocatable = 18 [default = true];
554
 
  inline bool has_url_relocatable() const;
555
 
  inline void clear_url_relocatable();
556
 
  static const int kUrlRelocatableFieldNumber = 18;
557
 
  inline bool url_relocatable() const;
558
 
  inline void set_url_relocatable(bool value);
559
 
 
560
 
  // optional bool canonicalize_url = 19 [default = false];
561
 
  inline bool has_canonicalize_url() const;
562
 
  inline void clear_canonicalize_url();
563
 
  static const int kCanonicalizeUrlFieldNumber = 19;
564
 
  inline bool canonicalize_url() const;
565
 
  inline void set_canonicalize_url(bool value);
566
 
 
567
 
  // optional int64 size = 20;
568
 
  inline bool has_size() const;
569
 
  inline void clear_size();
570
 
  static const int kSizeFieldNumber = 20;
571
 
  inline ::google::protobuf::int64 size() const;
572
 
  inline void set_size(::google::protobuf::int64 value);
573
 
 
574
 
  // repeated string debug_message = 21;
575
 
  inline int debug_message_size() const;
576
 
  inline void clear_debug_message();
577
 
  static const int kDebugMessageFieldNumber = 21;
578
 
  inline const ::std::string& debug_message(int index) const;
579
 
  inline ::std::string* mutable_debug_message(int index);
580
 
  inline void set_debug_message(int index, const ::std::string& value);
581
 
  inline void set_debug_message(int index, const char* value);
582
 
  inline void set_debug_message(int index, const char* value, size_t size);
583
 
  inline ::std::string* add_debug_message();
584
 
  inline void add_debug_message(const ::std::string& value);
585
 
  inline void add_debug_message(const char* value);
586
 
  inline void add_debug_message(const char* value, size_t size);
587
 
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& debug_message() const;
588
 
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_debug_message();
589
 
 
590
 
  // optional .net_instaweb.ResourceContext.LibWebpLevel minimal_webp_support = 22 [default = LIBWEBP_LOSSY_ONLY];
591
 
  inline bool has_minimal_webp_support() const;
592
 
  inline void clear_minimal_webp_support();
593
 
  static const int kMinimalWebpSupportFieldNumber = 22;
594
 
  inline ::net_instaweb::ResourceContext_LibWebpLevel minimal_webp_support() const;
595
 
  inline void set_minimal_webp_support(::net_instaweb::ResourceContext_LibWebpLevel value);
596
 
 
597
 
  // @@protoc_insertion_point(class_scope:net_instaweb.CachedResult)
598
 
 private:
599
 
  inline void set_has_optimizable();
600
 
  inline void clear_has_optimizable();
601
 
  inline void set_has_url();
602
 
  inline void clear_has_url();
603
 
  inline void set_has_frozen();
604
 
  inline void clear_has_frozen();
605
 
  inline void set_has_hash();
606
 
  inline void clear_has_hash();
607
 
  inline void set_has_extension();
608
 
  inline void clear_has_extension();
609
 
  inline void set_has_image_file_dims();
610
 
  inline void clear_has_image_file_dims();
611
 
  inline void set_has_inlined_data();
612
 
  inline void clear_has_inlined_data();
613
 
  inline void set_has_spriter_result();
614
 
  inline void clear_has_spriter_result();
615
 
  inline void set_has_inlined_image_type();
616
 
  inline void clear_has_inlined_image_type();
617
 
  inline void set_has_low_resolution_inlined_data();
618
 
  inline void clear_has_low_resolution_inlined_data();
619
 
  inline void set_has_low_resolution_inlined_image_type();
620
 
  inline void clear_has_low_resolution_inlined_image_type();
621
 
  inline void set_has_url_relocatable();
622
 
  inline void clear_has_url_relocatable();
623
 
  inline void set_has_canonicalize_url();
624
 
  inline void clear_has_canonicalize_url();
625
 
  inline void set_has_size();
626
 
  inline void clear_has_size();
627
 
  inline void set_has_minimal_webp_support();
628
 
  inline void clear_has_minimal_webp_support();
629
 
 
630
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
631
 
 
632
 
  ::std::string* url_;
633
 
  ::std::string* hash_;
634
 
  ::std::string* extension_;
635
 
  ::net_instaweb::ImageDim* image_file_dims_;
636
 
  ::std::string* inlined_data_;
637
 
  ::net_instaweb::spriter::SpriterResult* spriter_result_;
638
 
  bool optimizable_;
639
 
  bool frozen_;
640
 
  bool url_relocatable_;
641
 
  bool canonicalize_url_;
642
 
  ::google::protobuf::int32 inlined_image_type_;
643
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo > input_;
644
 
  ::std::string* low_resolution_inlined_data_;
645
 
  ::google::protobuf::int32 low_resolution_inlined_image_type_;
646
 
  int minimal_webp_support_;
647
 
  ::google::protobuf::int64 size_;
648
 
  ::google::protobuf::RepeatedPtrField< ::std::string> debug_message_;
649
 
 
650
 
  mutable int _cached_size_;
651
 
  ::google::protobuf::uint32 _has_bits_[(17 + 31) / 32];
652
 
 
653
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
654
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
655
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
656
 
 
657
 
  void InitAsDefaultInstance();
658
 
  static CachedResult* default_instance_;
659
 
};
660
 
// -------------------------------------------------------------------
661
 
 
662
 
class OutputPartitions : public ::google::protobuf::Message {
663
 
 public:
664
 
  OutputPartitions();
665
 
  virtual ~OutputPartitions();
666
 
 
667
 
  OutputPartitions(const OutputPartitions& from);
668
 
 
669
 
  inline OutputPartitions& operator=(const OutputPartitions& from) {
670
 
    CopyFrom(from);
671
 
    return *this;
672
 
  }
673
 
 
674
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
675
 
    return _unknown_fields_;
676
 
  }
677
 
 
678
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
679
 
    return &_unknown_fields_;
680
 
  }
681
 
 
682
 
  static const ::google::protobuf::Descriptor* descriptor();
683
 
  static const OutputPartitions& default_instance();
684
 
 
685
 
  void Swap(OutputPartitions* other);
686
 
 
687
 
  // implements Message ----------------------------------------------
688
 
 
689
 
  OutputPartitions* New() const;
690
 
  void CopyFrom(const ::google::protobuf::Message& from);
691
 
  void MergeFrom(const ::google::protobuf::Message& from);
692
 
  void CopyFrom(const OutputPartitions& from);
693
 
  void MergeFrom(const OutputPartitions& from);
694
 
  void Clear();
695
 
  bool IsInitialized() const;
696
 
 
697
 
  int ByteSize() const;
698
 
  bool MergePartialFromCodedStream(
699
 
      ::google::protobuf::io::CodedInputStream* input);
700
 
  void SerializeWithCachedSizes(
701
 
      ::google::protobuf::io::CodedOutputStream* output) const;
702
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
703
 
  int GetCachedSize() const { return _cached_size_; }
704
 
  private:
705
 
  void SharedCtor();
706
 
  void SharedDtor();
707
 
  void SetCachedSize(int size) const;
708
 
  public:
709
 
 
710
 
  ::google::protobuf::Metadata GetMetadata() const;
711
 
 
712
 
  // nested types ----------------------------------------------------
713
 
 
714
 
  // accessors -------------------------------------------------------
715
 
 
716
 
  // repeated .net_instaweb.CachedResult partition = 1;
717
 
  inline int partition_size() const;
718
 
  inline void clear_partition();
719
 
  static const int kPartitionFieldNumber = 1;
720
 
  inline const ::net_instaweb::CachedResult& partition(int index) const;
721
 
  inline ::net_instaweb::CachedResult* mutable_partition(int index);
722
 
  inline ::net_instaweb::CachedResult* add_partition();
723
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CachedResult >&
724
 
      partition() const;
725
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CachedResult >*
726
 
      mutable_partition();
727
 
 
728
 
  // repeated .net_instaweb.InputInfo other_dependency = 2;
729
 
  inline int other_dependency_size() const;
730
 
  inline void clear_other_dependency();
731
 
  static const int kOtherDependencyFieldNumber = 2;
732
 
  inline const ::net_instaweb::InputInfo& other_dependency(int index) const;
733
 
  inline ::net_instaweb::InputInfo* mutable_other_dependency(int index);
734
 
  inline ::net_instaweb::InputInfo* add_other_dependency();
735
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >&
736
 
      other_dependency() const;
737
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >*
738
 
      mutable_other_dependency();
739
 
 
740
 
  // repeated string debug_message = 3;
741
 
  inline int debug_message_size() const;
742
 
  inline void clear_debug_message();
743
 
  static const int kDebugMessageFieldNumber = 3;
744
 
  inline const ::std::string& debug_message(int index) const;
745
 
  inline ::std::string* mutable_debug_message(int index);
746
 
  inline void set_debug_message(int index, const ::std::string& value);
747
 
  inline void set_debug_message(int index, const char* value);
748
 
  inline void set_debug_message(int index, const char* value, size_t size);
749
 
  inline ::std::string* add_debug_message();
750
 
  inline void add_debug_message(const ::std::string& value);
751
 
  inline void add_debug_message(const char* value);
752
 
  inline void add_debug_message(const char* value, size_t size);
753
 
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& debug_message() const;
754
 
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_debug_message();
755
 
 
756
 
  // @@protoc_insertion_point(class_scope:net_instaweb.OutputPartitions)
757
 
 private:
758
 
 
759
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
760
 
 
761
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::CachedResult > partition_;
762
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo > other_dependency_;
763
 
  ::google::protobuf::RepeatedPtrField< ::std::string> debug_message_;
764
 
 
765
 
  mutable int _cached_size_;
766
 
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
767
 
 
768
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
769
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
770
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
771
 
 
772
 
  void InitAsDefaultInstance();
773
 
  static OutputPartitions* default_instance_;
774
 
};
775
 
// -------------------------------------------------------------------
776
 
 
777
 
class ResourceContext : public ::google::protobuf::Message {
778
 
 public:
779
 
  ResourceContext();
780
 
  virtual ~ResourceContext();
781
 
 
782
 
  ResourceContext(const ResourceContext& from);
783
 
 
784
 
  inline ResourceContext& operator=(const ResourceContext& from) {
785
 
    CopyFrom(from);
786
 
    return *this;
787
 
  }
788
 
 
789
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
790
 
    return _unknown_fields_;
791
 
  }
792
 
 
793
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
794
 
    return &_unknown_fields_;
795
 
  }
796
 
 
797
 
  static const ::google::protobuf::Descriptor* descriptor();
798
 
  static const ResourceContext& default_instance();
799
 
 
800
 
  void Swap(ResourceContext* other);
801
 
 
802
 
  // implements Message ----------------------------------------------
803
 
 
804
 
  ResourceContext* New() const;
805
 
  void CopyFrom(const ::google::protobuf::Message& from);
806
 
  void MergeFrom(const ::google::protobuf::Message& from);
807
 
  void CopyFrom(const ResourceContext& from);
808
 
  void MergeFrom(const ResourceContext& from);
809
 
  void Clear();
810
 
  bool IsInitialized() const;
811
 
 
812
 
  int ByteSize() const;
813
 
  bool MergePartialFromCodedStream(
814
 
      ::google::protobuf::io::CodedInputStream* input);
815
 
  void SerializeWithCachedSizes(
816
 
      ::google::protobuf::io::CodedOutputStream* output) const;
817
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
818
 
  int GetCachedSize() const { return _cached_size_; }
819
 
  private:
820
 
  void SharedCtor();
821
 
  void SharedDtor();
822
 
  void SetCachedSize(int size) const;
823
 
  public:
824
 
 
825
 
  ::google::protobuf::Metadata GetMetadata() const;
826
 
 
827
 
  // nested types ----------------------------------------------------
828
 
 
829
 
  typedef ResourceContext_LibWebpLevel LibWebpLevel;
830
 
  static const LibWebpLevel LIBWEBP_NONE = ResourceContext_LibWebpLevel_LIBWEBP_NONE;
831
 
  static const LibWebpLevel LIBWEBP_LOSSY_ONLY = ResourceContext_LibWebpLevel_LIBWEBP_LOSSY_ONLY;
832
 
  static const LibWebpLevel LIBWEBP_LOSSY_LOSSLESS_ALPHA = ResourceContext_LibWebpLevel_LIBWEBP_LOSSY_LOSSLESS_ALPHA;
833
 
  static inline bool LibWebpLevel_IsValid(int value) {
834
 
    return ResourceContext_LibWebpLevel_IsValid(value);
835
 
  }
836
 
  static const LibWebpLevel LibWebpLevel_MIN =
837
 
    ResourceContext_LibWebpLevel_LibWebpLevel_MIN;
838
 
  static const LibWebpLevel LibWebpLevel_MAX =
839
 
    ResourceContext_LibWebpLevel_LibWebpLevel_MAX;
840
 
  static const int LibWebpLevel_ARRAYSIZE =
841
 
    ResourceContext_LibWebpLevel_LibWebpLevel_ARRAYSIZE;
842
 
  static inline const ::google::protobuf::EnumDescriptor*
843
 
  LibWebpLevel_descriptor() {
844
 
    return ResourceContext_LibWebpLevel_descriptor();
845
 
  }
846
 
  static inline const ::std::string& LibWebpLevel_Name(LibWebpLevel value) {
847
 
    return ResourceContext_LibWebpLevel_Name(value);
848
 
  }
849
 
  static inline bool LibWebpLevel_Parse(const ::std::string& name,
850
 
      LibWebpLevel* value) {
851
 
    return ResourceContext_LibWebpLevel_Parse(name, value);
852
 
  }
853
 
 
854
 
  // accessors -------------------------------------------------------
855
 
 
856
 
  // optional .net_instaweb.ImageDim desired_image_dims = 1;
857
 
  inline bool has_desired_image_dims() const;
858
 
  inline void clear_desired_image_dims();
859
 
  static const int kDesiredImageDimsFieldNumber = 1;
860
 
  inline const ::net_instaweb::ImageDim& desired_image_dims() const;
861
 
  inline ::net_instaweb::ImageDim* mutable_desired_image_dims();
862
 
  inline ::net_instaweb::ImageDim* release_desired_image_dims();
863
 
  inline void set_allocated_desired_image_dims(::net_instaweb::ImageDim* desired_image_dims);
864
 
 
865
 
  // optional bool attempt_webp = 2 [default = false, deprecated = true];
866
 
  inline bool has_attempt_webp() const PROTOBUF_DEPRECATED;
867
 
  inline void clear_attempt_webp() PROTOBUF_DEPRECATED;
868
 
  static const int kAttemptWebpFieldNumber = 2;
869
 
  inline bool attempt_webp() const PROTOBUF_DEPRECATED;
870
 
  inline void set_attempt_webp(bool value) PROTOBUF_DEPRECATED;
871
 
 
872
 
  // optional bool inline_images = 3 [default = true];
873
 
  inline bool has_inline_images() const;
874
 
  inline void clear_inline_images();
875
 
  static const int kInlineImagesFieldNumber = 3;
876
 
  inline bool inline_images() const;
877
 
  inline void set_inline_images(bool value);
878
 
 
879
 
  // optional bool mobile_user_agent = 4 [default = false];
880
 
  inline bool has_mobile_user_agent() const;
881
 
  inline void clear_mobile_user_agent();
882
 
  static const int kMobileUserAgentFieldNumber = 4;
883
 
  inline bool mobile_user_agent() const;
884
 
  inline void set_mobile_user_agent(bool value);
885
 
 
886
 
  // optional .net_instaweb.ResourceContext.LibWebpLevel libwebp_level = 5 [default = LIBWEBP_NONE];
887
 
  inline bool has_libwebp_level() const;
888
 
  inline void clear_libwebp_level();
889
 
  static const int kLibwebpLevelFieldNumber = 5;
890
 
  inline ::net_instaweb::ResourceContext_LibWebpLevel libwebp_level() const;
891
 
  inline void set_libwebp_level(::net_instaweb::ResourceContext_LibWebpLevel value);
892
 
 
893
 
  // optional .net_instaweb.ImageDim user_agent_screen_resolution = 6;
894
 
  inline bool has_user_agent_screen_resolution() const;
895
 
  inline void clear_user_agent_screen_resolution();
896
 
  static const int kUserAgentScreenResolutionFieldNumber = 6;
897
 
  inline const ::net_instaweb::ImageDim& user_agent_screen_resolution() const;
898
 
  inline ::net_instaweb::ImageDim* mutable_user_agent_screen_resolution();
899
 
  inline ::net_instaweb::ImageDim* release_user_agent_screen_resolution();
900
 
  inline void set_allocated_user_agent_screen_resolution(::net_instaweb::ImageDim* user_agent_screen_resolution);
901
 
 
902
 
  // optional bool use_small_screen_quality = 7 [default = false];
903
 
  inline bool has_use_small_screen_quality() const;
904
 
  inline void clear_use_small_screen_quality();
905
 
  static const int kUseSmallScreenQualityFieldNumber = 7;
906
 
  inline bool use_small_screen_quality() const;
907
 
  inline void set_use_small_screen_quality(bool value);
908
 
 
909
 
  // @@protoc_insertion_point(class_scope:net_instaweb.ResourceContext)
910
 
 private:
911
 
  inline void set_has_desired_image_dims();
912
 
  inline void clear_has_desired_image_dims();
913
 
  inline void set_has_attempt_webp();
914
 
  inline void clear_has_attempt_webp();
915
 
  inline void set_has_inline_images();
916
 
  inline void clear_has_inline_images();
917
 
  inline void set_has_mobile_user_agent();
918
 
  inline void clear_has_mobile_user_agent();
919
 
  inline void set_has_libwebp_level();
920
 
  inline void clear_has_libwebp_level();
921
 
  inline void set_has_user_agent_screen_resolution();
922
 
  inline void clear_has_user_agent_screen_resolution();
923
 
  inline void set_has_use_small_screen_quality();
924
 
  inline void clear_has_use_small_screen_quality();
925
 
 
926
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
927
 
 
928
 
  ::net_instaweb::ImageDim* desired_image_dims_;
929
 
  bool attempt_webp_;
930
 
  bool inline_images_;
931
 
  bool mobile_user_agent_;
932
 
  bool use_small_screen_quality_;
933
 
  int libwebp_level_;
934
 
  ::net_instaweb::ImageDim* user_agent_screen_resolution_;
935
 
 
936
 
  mutable int _cached_size_;
937
 
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
938
 
 
939
 
  friend void  protobuf_AddDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
940
 
  friend void protobuf_AssignDesc_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
941
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto();
942
 
 
943
 
  void InitAsDefaultInstance();
944
 
  static ResourceContext* default_instance_;
945
 
};
946
 
// ===================================================================
947
 
 
948
 
 
949
 
// ===================================================================
950
 
 
951
 
// ImageDim
952
 
 
953
 
// optional int32 width = 1 [default = -1];
954
 
inline bool ImageDim::has_width() const {
955
 
  return (_has_bits_[0] & 0x00000001u) != 0;
956
 
}
957
 
inline void ImageDim::set_has_width() {
958
 
  _has_bits_[0] |= 0x00000001u;
959
 
}
960
 
inline void ImageDim::clear_has_width() {
961
 
  _has_bits_[0] &= ~0x00000001u;
962
 
}
963
 
inline void ImageDim::clear_width() {
964
 
  width_ = -1;
965
 
  clear_has_width();
966
 
}
967
 
inline ::google::protobuf::int32 ImageDim::width() const {
968
 
  return width_;
969
 
}
970
 
inline void ImageDim::set_width(::google::protobuf::int32 value) {
971
 
  set_has_width();
972
 
  width_ = value;
973
 
}
974
 
 
975
 
// optional int32 height = 2 [default = -1];
976
 
inline bool ImageDim::has_height() const {
977
 
  return (_has_bits_[0] & 0x00000002u) != 0;
978
 
}
979
 
inline void ImageDim::set_has_height() {
980
 
  _has_bits_[0] |= 0x00000002u;
981
 
}
982
 
inline void ImageDim::clear_has_height() {
983
 
  _has_bits_[0] &= ~0x00000002u;
984
 
}
985
 
inline void ImageDim::clear_height() {
986
 
  height_ = -1;
987
 
  clear_has_height();
988
 
}
989
 
inline ::google::protobuf::int32 ImageDim::height() const {
990
 
  return height_;
991
 
}
992
 
inline void ImageDim::set_height(::google::protobuf::int32 value) {
993
 
  set_has_height();
994
 
  height_ = value;
995
 
}
996
 
 
997
 
// -------------------------------------------------------------------
998
 
 
999
 
// InputInfo
1000
 
 
1001
 
// optional int32 index = 1;
1002
 
inline bool InputInfo::has_index() const {
1003
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1004
 
}
1005
 
inline void InputInfo::set_has_index() {
1006
 
  _has_bits_[0] |= 0x00000001u;
1007
 
}
1008
 
inline void InputInfo::clear_has_index() {
1009
 
  _has_bits_[0] &= ~0x00000001u;
1010
 
}
1011
 
inline void InputInfo::clear_index() {
1012
 
  index_ = 0;
1013
 
  clear_has_index();
1014
 
}
1015
 
inline ::google::protobuf::int32 InputInfo::index() const {
1016
 
  return index_;
1017
 
}
1018
 
inline void InputInfo::set_index(::google::protobuf::int32 value) {
1019
 
  set_has_index();
1020
 
  index_ = value;
1021
 
}
1022
 
 
1023
 
// required .net_instaweb.InputInfo.Type type = 2;
1024
 
inline bool InputInfo::has_type() const {
1025
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1026
 
}
1027
 
inline void InputInfo::set_has_type() {
1028
 
  _has_bits_[0] |= 0x00000002u;
1029
 
}
1030
 
inline void InputInfo::clear_has_type() {
1031
 
  _has_bits_[0] &= ~0x00000002u;
1032
 
}
1033
 
inline void InputInfo::clear_type() {
1034
 
  type_ = 1;
1035
 
  clear_has_type();
1036
 
}
1037
 
inline ::net_instaweb::InputInfo_Type InputInfo::type() const {
1038
 
  return static_cast< ::net_instaweb::InputInfo_Type >(type_);
1039
 
}
1040
 
inline void InputInfo::set_type(::net_instaweb::InputInfo_Type value) {
1041
 
  assert(::net_instaweb::InputInfo_Type_IsValid(value));
1042
 
  set_has_type();
1043
 
  type_ = value;
1044
 
}
1045
 
 
1046
 
// optional int64 last_modified_time_ms = 3;
1047
 
inline bool InputInfo::has_last_modified_time_ms() const {
1048
 
  return (_has_bits_[0] & 0x00000004u) != 0;
1049
 
}
1050
 
inline void InputInfo::set_has_last_modified_time_ms() {
1051
 
  _has_bits_[0] |= 0x00000004u;
1052
 
}
1053
 
inline void InputInfo::clear_has_last_modified_time_ms() {
1054
 
  _has_bits_[0] &= ~0x00000004u;
1055
 
}
1056
 
inline void InputInfo::clear_last_modified_time_ms() {
1057
 
  last_modified_time_ms_ = GOOGLE_LONGLONG(0);
1058
 
  clear_has_last_modified_time_ms();
1059
 
}
1060
 
inline ::google::protobuf::int64 InputInfo::last_modified_time_ms() const {
1061
 
  return last_modified_time_ms_;
1062
 
}
1063
 
inline void InputInfo::set_last_modified_time_ms(::google::protobuf::int64 value) {
1064
 
  set_has_last_modified_time_ms();
1065
 
  last_modified_time_ms_ = value;
1066
 
}
1067
 
 
1068
 
// optional int64 expiration_time_ms = 4;
1069
 
inline bool InputInfo::has_expiration_time_ms() const {
1070
 
  return (_has_bits_[0] & 0x00000008u) != 0;
1071
 
}
1072
 
inline void InputInfo::set_has_expiration_time_ms() {
1073
 
  _has_bits_[0] |= 0x00000008u;
1074
 
}
1075
 
inline void InputInfo::clear_has_expiration_time_ms() {
1076
 
  _has_bits_[0] &= ~0x00000008u;
1077
 
}
1078
 
inline void InputInfo::clear_expiration_time_ms() {
1079
 
  expiration_time_ms_ = GOOGLE_LONGLONG(0);
1080
 
  clear_has_expiration_time_ms();
1081
 
}
1082
 
inline ::google::protobuf::int64 InputInfo::expiration_time_ms() const {
1083
 
  return expiration_time_ms_;
1084
 
}
1085
 
inline void InputInfo::set_expiration_time_ms(::google::protobuf::int64 value) {
1086
 
  set_has_expiration_time_ms();
1087
 
  expiration_time_ms_ = value;
1088
 
}
1089
 
 
1090
 
// optional string filename = 5;
1091
 
inline bool InputInfo::has_filename() const {
1092
 
  return (_has_bits_[0] & 0x00000010u) != 0;
1093
 
}
1094
 
inline void InputInfo::set_has_filename() {
1095
 
  _has_bits_[0] |= 0x00000010u;
1096
 
}
1097
 
inline void InputInfo::clear_has_filename() {
1098
 
  _has_bits_[0] &= ~0x00000010u;
1099
 
}
1100
 
inline void InputInfo::clear_filename() {
1101
 
  if (filename_ != &::google::protobuf::internal::GetEmptyString()) {
1102
 
    filename_->clear();
1103
 
  }
1104
 
  clear_has_filename();
1105
 
}
1106
 
inline const ::std::string& InputInfo::filename() const {
1107
 
  return *filename_;
1108
 
}
1109
 
inline void InputInfo::set_filename(const ::std::string& value) {
1110
 
  set_has_filename();
1111
 
  if (filename_ == &::google::protobuf::internal::GetEmptyString()) {
1112
 
    filename_ = new ::std::string;
1113
 
  }
1114
 
  filename_->assign(value);
1115
 
}
1116
 
inline void InputInfo::set_filename(const char* value) {
1117
 
  set_has_filename();
1118
 
  if (filename_ == &::google::protobuf::internal::GetEmptyString()) {
1119
 
    filename_ = new ::std::string;
1120
 
  }
1121
 
  filename_->assign(value);
1122
 
}
1123
 
inline void InputInfo::set_filename(const char* value, size_t size) {
1124
 
  set_has_filename();
1125
 
  if (filename_ == &::google::protobuf::internal::GetEmptyString()) {
1126
 
    filename_ = new ::std::string;
1127
 
  }
1128
 
  filename_->assign(reinterpret_cast<const char*>(value), size);
1129
 
}
1130
 
inline ::std::string* InputInfo::mutable_filename() {
1131
 
  set_has_filename();
1132
 
  if (filename_ == &::google::protobuf::internal::GetEmptyString()) {
1133
 
    filename_ = new ::std::string;
1134
 
  }
1135
 
  return filename_;
1136
 
}
1137
 
inline ::std::string* InputInfo::release_filename() {
1138
 
  clear_has_filename();
1139
 
  if (filename_ == &::google::protobuf::internal::GetEmptyString()) {
1140
 
    return NULL;
1141
 
  } else {
1142
 
    ::std::string* temp = filename_;
1143
 
    filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1144
 
    return temp;
1145
 
  }
1146
 
}
1147
 
inline void InputInfo::set_allocated_filename(::std::string* filename) {
1148
 
  if (filename_ != &::google::protobuf::internal::GetEmptyString()) {
1149
 
    delete filename_;
1150
 
  }
1151
 
  if (filename) {
1152
 
    set_has_filename();
1153
 
    filename_ = filename;
1154
 
  } else {
1155
 
    clear_has_filename();
1156
 
    filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1157
 
  }
1158
 
}
1159
 
 
1160
 
// optional int64 date_ms = 6;
1161
 
inline bool InputInfo::has_date_ms() const {
1162
 
  return (_has_bits_[0] & 0x00000020u) != 0;
1163
 
}
1164
 
inline void InputInfo::set_has_date_ms() {
1165
 
  _has_bits_[0] |= 0x00000020u;
1166
 
}
1167
 
inline void InputInfo::clear_has_date_ms() {
1168
 
  _has_bits_[0] &= ~0x00000020u;
1169
 
}
1170
 
inline void InputInfo::clear_date_ms() {
1171
 
  date_ms_ = GOOGLE_LONGLONG(0);
1172
 
  clear_has_date_ms();
1173
 
}
1174
 
inline ::google::protobuf::int64 InputInfo::date_ms() const {
1175
 
  return date_ms_;
1176
 
}
1177
 
inline void InputInfo::set_date_ms(::google::protobuf::int64 value) {
1178
 
  set_has_date_ms();
1179
 
  date_ms_ = value;
1180
 
}
1181
 
 
1182
 
// optional string input_content_hash = 7;
1183
 
inline bool InputInfo::has_input_content_hash() const {
1184
 
  return (_has_bits_[0] & 0x00000040u) != 0;
1185
 
}
1186
 
inline void InputInfo::set_has_input_content_hash() {
1187
 
  _has_bits_[0] |= 0x00000040u;
1188
 
}
1189
 
inline void InputInfo::clear_has_input_content_hash() {
1190
 
  _has_bits_[0] &= ~0x00000040u;
1191
 
}
1192
 
inline void InputInfo::clear_input_content_hash() {
1193
 
  if (input_content_hash_ != &::google::protobuf::internal::GetEmptyString()) {
1194
 
    input_content_hash_->clear();
1195
 
  }
1196
 
  clear_has_input_content_hash();
1197
 
}
1198
 
inline const ::std::string& InputInfo::input_content_hash() const {
1199
 
  return *input_content_hash_;
1200
 
}
1201
 
inline void InputInfo::set_input_content_hash(const ::std::string& value) {
1202
 
  set_has_input_content_hash();
1203
 
  if (input_content_hash_ == &::google::protobuf::internal::GetEmptyString()) {
1204
 
    input_content_hash_ = new ::std::string;
1205
 
  }
1206
 
  input_content_hash_->assign(value);
1207
 
}
1208
 
inline void InputInfo::set_input_content_hash(const char* value) {
1209
 
  set_has_input_content_hash();
1210
 
  if (input_content_hash_ == &::google::protobuf::internal::GetEmptyString()) {
1211
 
    input_content_hash_ = new ::std::string;
1212
 
  }
1213
 
  input_content_hash_->assign(value);
1214
 
}
1215
 
inline void InputInfo::set_input_content_hash(const char* value, size_t size) {
1216
 
  set_has_input_content_hash();
1217
 
  if (input_content_hash_ == &::google::protobuf::internal::GetEmptyString()) {
1218
 
    input_content_hash_ = new ::std::string;
1219
 
  }
1220
 
  input_content_hash_->assign(reinterpret_cast<const char*>(value), size);
1221
 
}
1222
 
inline ::std::string* InputInfo::mutable_input_content_hash() {
1223
 
  set_has_input_content_hash();
1224
 
  if (input_content_hash_ == &::google::protobuf::internal::GetEmptyString()) {
1225
 
    input_content_hash_ = new ::std::string;
1226
 
  }
1227
 
  return input_content_hash_;
1228
 
}
1229
 
inline ::std::string* InputInfo::release_input_content_hash() {
1230
 
  clear_has_input_content_hash();
1231
 
  if (input_content_hash_ == &::google::protobuf::internal::GetEmptyString()) {
1232
 
    return NULL;
1233
 
  } else {
1234
 
    ::std::string* temp = input_content_hash_;
1235
 
    input_content_hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1236
 
    return temp;
1237
 
  }
1238
 
}
1239
 
inline void InputInfo::set_allocated_input_content_hash(::std::string* input_content_hash) {
1240
 
  if (input_content_hash_ != &::google::protobuf::internal::GetEmptyString()) {
1241
 
    delete input_content_hash_;
1242
 
  }
1243
 
  if (input_content_hash) {
1244
 
    set_has_input_content_hash();
1245
 
    input_content_hash_ = input_content_hash;
1246
 
  } else {
1247
 
    clear_has_input_content_hash();
1248
 
    input_content_hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1249
 
  }
1250
 
}
1251
 
 
1252
 
// optional bool disable_further_processing = 8 [default = false];
1253
 
inline bool InputInfo::has_disable_further_processing() const {
1254
 
  return (_has_bits_[0] & 0x00000080u) != 0;
1255
 
}
1256
 
inline void InputInfo::set_has_disable_further_processing() {
1257
 
  _has_bits_[0] |= 0x00000080u;
1258
 
}
1259
 
inline void InputInfo::clear_has_disable_further_processing() {
1260
 
  _has_bits_[0] &= ~0x00000080u;
1261
 
}
1262
 
inline void InputInfo::clear_disable_further_processing() {
1263
 
  disable_further_processing_ = false;
1264
 
  clear_has_disable_further_processing();
1265
 
}
1266
 
inline bool InputInfo::disable_further_processing() const {
1267
 
  return disable_further_processing_;
1268
 
}
1269
 
inline void InputInfo::set_disable_further_processing(bool value) {
1270
 
  set_has_disable_further_processing();
1271
 
  disable_further_processing_ = value;
1272
 
}
1273
 
 
1274
 
// optional string url = 9;
1275
 
inline bool InputInfo::has_url() const {
1276
 
  return (_has_bits_[0] & 0x00000100u) != 0;
1277
 
}
1278
 
inline void InputInfo::set_has_url() {
1279
 
  _has_bits_[0] |= 0x00000100u;
1280
 
}
1281
 
inline void InputInfo::clear_has_url() {
1282
 
  _has_bits_[0] &= ~0x00000100u;
1283
 
}
1284
 
inline void InputInfo::clear_url() {
1285
 
  if (url_ != &::google::protobuf::internal::GetEmptyString()) {
1286
 
    url_->clear();
1287
 
  }
1288
 
  clear_has_url();
1289
 
}
1290
 
inline const ::std::string& InputInfo::url() const {
1291
 
  return *url_;
1292
 
}
1293
 
inline void InputInfo::set_url(const ::std::string& value) {
1294
 
  set_has_url();
1295
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1296
 
    url_ = new ::std::string;
1297
 
  }
1298
 
  url_->assign(value);
1299
 
}
1300
 
inline void InputInfo::set_url(const char* value) {
1301
 
  set_has_url();
1302
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1303
 
    url_ = new ::std::string;
1304
 
  }
1305
 
  url_->assign(value);
1306
 
}
1307
 
inline void InputInfo::set_url(const char* value, size_t size) {
1308
 
  set_has_url();
1309
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1310
 
    url_ = new ::std::string;
1311
 
  }
1312
 
  url_->assign(reinterpret_cast<const char*>(value), size);
1313
 
}
1314
 
inline ::std::string* InputInfo::mutable_url() {
1315
 
  set_has_url();
1316
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1317
 
    url_ = new ::std::string;
1318
 
  }
1319
 
  return url_;
1320
 
}
1321
 
inline ::std::string* InputInfo::release_url() {
1322
 
  clear_has_url();
1323
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1324
 
    return NULL;
1325
 
  } else {
1326
 
    ::std::string* temp = url_;
1327
 
    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1328
 
    return temp;
1329
 
  }
1330
 
}
1331
 
inline void InputInfo::set_allocated_url(::std::string* url) {
1332
 
  if (url_ != &::google::protobuf::internal::GetEmptyString()) {
1333
 
    delete url_;
1334
 
  }
1335
 
  if (url) {
1336
 
    set_has_url();
1337
 
    url_ = url;
1338
 
  } else {
1339
 
    clear_has_url();
1340
 
    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1341
 
  }
1342
 
}
1343
 
 
1344
 
// -------------------------------------------------------------------
1345
 
 
1346
 
// CachedResult
1347
 
 
1348
 
// optional bool optimizable = 1 [default = true];
1349
 
inline bool CachedResult::has_optimizable() const {
1350
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1351
 
}
1352
 
inline void CachedResult::set_has_optimizable() {
1353
 
  _has_bits_[0] |= 0x00000001u;
1354
 
}
1355
 
inline void CachedResult::clear_has_optimizable() {
1356
 
  _has_bits_[0] &= ~0x00000001u;
1357
 
}
1358
 
inline void CachedResult::clear_optimizable() {
1359
 
  optimizable_ = true;
1360
 
  clear_has_optimizable();
1361
 
}
1362
 
inline bool CachedResult::optimizable() const {
1363
 
  return optimizable_;
1364
 
}
1365
 
inline void CachedResult::set_optimizable(bool value) {
1366
 
  set_has_optimizable();
1367
 
  optimizable_ = value;
1368
 
}
1369
 
 
1370
 
// optional string url = 2;
1371
 
inline bool CachedResult::has_url() const {
1372
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1373
 
}
1374
 
inline void CachedResult::set_has_url() {
1375
 
  _has_bits_[0] |= 0x00000002u;
1376
 
}
1377
 
inline void CachedResult::clear_has_url() {
1378
 
  _has_bits_[0] &= ~0x00000002u;
1379
 
}
1380
 
inline void CachedResult::clear_url() {
1381
 
  if (url_ != &::google::protobuf::internal::GetEmptyString()) {
1382
 
    url_->clear();
1383
 
  }
1384
 
  clear_has_url();
1385
 
}
1386
 
inline const ::std::string& CachedResult::url() const {
1387
 
  return *url_;
1388
 
}
1389
 
inline void CachedResult::set_url(const ::std::string& value) {
1390
 
  set_has_url();
1391
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1392
 
    url_ = new ::std::string;
1393
 
  }
1394
 
  url_->assign(value);
1395
 
}
1396
 
inline void CachedResult::set_url(const char* value) {
1397
 
  set_has_url();
1398
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1399
 
    url_ = new ::std::string;
1400
 
  }
1401
 
  url_->assign(value);
1402
 
}
1403
 
inline void CachedResult::set_url(const char* value, size_t size) {
1404
 
  set_has_url();
1405
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1406
 
    url_ = new ::std::string;
1407
 
  }
1408
 
  url_->assign(reinterpret_cast<const char*>(value), size);
1409
 
}
1410
 
inline ::std::string* CachedResult::mutable_url() {
1411
 
  set_has_url();
1412
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1413
 
    url_ = new ::std::string;
1414
 
  }
1415
 
  return url_;
1416
 
}
1417
 
inline ::std::string* CachedResult::release_url() {
1418
 
  clear_has_url();
1419
 
  if (url_ == &::google::protobuf::internal::GetEmptyString()) {
1420
 
    return NULL;
1421
 
  } else {
1422
 
    ::std::string* temp = url_;
1423
 
    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1424
 
    return temp;
1425
 
  }
1426
 
}
1427
 
inline void CachedResult::set_allocated_url(::std::string* url) {
1428
 
  if (url_ != &::google::protobuf::internal::GetEmptyString()) {
1429
 
    delete url_;
1430
 
  }
1431
 
  if (url) {
1432
 
    set_has_url();
1433
 
    url_ = url;
1434
 
  } else {
1435
 
    clear_has_url();
1436
 
    url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1437
 
  }
1438
 
}
1439
 
 
1440
 
// optional bool frozen = 5 [default = false];
1441
 
inline bool CachedResult::has_frozen() const {
1442
 
  return (_has_bits_[0] & 0x00000004u) != 0;
1443
 
}
1444
 
inline void CachedResult::set_has_frozen() {
1445
 
  _has_bits_[0] |= 0x00000004u;
1446
 
}
1447
 
inline void CachedResult::clear_has_frozen() {
1448
 
  _has_bits_[0] &= ~0x00000004u;
1449
 
}
1450
 
inline void CachedResult::clear_frozen() {
1451
 
  frozen_ = false;
1452
 
  clear_has_frozen();
1453
 
}
1454
 
inline bool CachedResult::frozen() const {
1455
 
  return frozen_;
1456
 
}
1457
 
inline void CachedResult::set_frozen(bool value) {
1458
 
  set_has_frozen();
1459
 
  frozen_ = value;
1460
 
}
1461
 
 
1462
 
// optional string hash = 6;
1463
 
inline bool CachedResult::has_hash() const {
1464
 
  return (_has_bits_[0] & 0x00000008u) != 0;
1465
 
}
1466
 
inline void CachedResult::set_has_hash() {
1467
 
  _has_bits_[0] |= 0x00000008u;
1468
 
}
1469
 
inline void CachedResult::clear_has_hash() {
1470
 
  _has_bits_[0] &= ~0x00000008u;
1471
 
}
1472
 
inline void CachedResult::clear_hash() {
1473
 
  if (hash_ != &::google::protobuf::internal::GetEmptyString()) {
1474
 
    hash_->clear();
1475
 
  }
1476
 
  clear_has_hash();
1477
 
}
1478
 
inline const ::std::string& CachedResult::hash() const {
1479
 
  return *hash_;
1480
 
}
1481
 
inline void CachedResult::set_hash(const ::std::string& value) {
1482
 
  set_has_hash();
1483
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
1484
 
    hash_ = new ::std::string;
1485
 
  }
1486
 
  hash_->assign(value);
1487
 
}
1488
 
inline void CachedResult::set_hash(const char* value) {
1489
 
  set_has_hash();
1490
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
1491
 
    hash_ = new ::std::string;
1492
 
  }
1493
 
  hash_->assign(value);
1494
 
}
1495
 
inline void CachedResult::set_hash(const char* value, size_t size) {
1496
 
  set_has_hash();
1497
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
1498
 
    hash_ = new ::std::string;
1499
 
  }
1500
 
  hash_->assign(reinterpret_cast<const char*>(value), size);
1501
 
}
1502
 
inline ::std::string* CachedResult::mutable_hash() {
1503
 
  set_has_hash();
1504
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
1505
 
    hash_ = new ::std::string;
1506
 
  }
1507
 
  return hash_;
1508
 
}
1509
 
inline ::std::string* CachedResult::release_hash() {
1510
 
  clear_has_hash();
1511
 
  if (hash_ == &::google::protobuf::internal::GetEmptyString()) {
1512
 
    return NULL;
1513
 
  } else {
1514
 
    ::std::string* temp = hash_;
1515
 
    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1516
 
    return temp;
1517
 
  }
1518
 
}
1519
 
inline void CachedResult::set_allocated_hash(::std::string* hash) {
1520
 
  if (hash_ != &::google::protobuf::internal::GetEmptyString()) {
1521
 
    delete hash_;
1522
 
  }
1523
 
  if (hash) {
1524
 
    set_has_hash();
1525
 
    hash_ = hash;
1526
 
  } else {
1527
 
    clear_has_hash();
1528
 
    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1529
 
  }
1530
 
}
1531
 
 
1532
 
// optional string extension = 7;
1533
 
inline bool CachedResult::has_extension() const {
1534
 
  return (_has_bits_[0] & 0x00000010u) != 0;
1535
 
}
1536
 
inline void CachedResult::set_has_extension() {
1537
 
  _has_bits_[0] |= 0x00000010u;
1538
 
}
1539
 
inline void CachedResult::clear_has_extension() {
1540
 
  _has_bits_[0] &= ~0x00000010u;
1541
 
}
1542
 
inline void CachedResult::clear_extension() {
1543
 
  if (extension_ != &::google::protobuf::internal::GetEmptyString()) {
1544
 
    extension_->clear();
1545
 
  }
1546
 
  clear_has_extension();
1547
 
}
1548
 
inline const ::std::string& CachedResult::extension() const {
1549
 
  return *extension_;
1550
 
}
1551
 
inline void CachedResult::set_extension(const ::std::string& value) {
1552
 
  set_has_extension();
1553
 
  if (extension_ == &::google::protobuf::internal::GetEmptyString()) {
1554
 
    extension_ = new ::std::string;
1555
 
  }
1556
 
  extension_->assign(value);
1557
 
}
1558
 
inline void CachedResult::set_extension(const char* value) {
1559
 
  set_has_extension();
1560
 
  if (extension_ == &::google::protobuf::internal::GetEmptyString()) {
1561
 
    extension_ = new ::std::string;
1562
 
  }
1563
 
  extension_->assign(value);
1564
 
}
1565
 
inline void CachedResult::set_extension(const char* value, size_t size) {
1566
 
  set_has_extension();
1567
 
  if (extension_ == &::google::protobuf::internal::GetEmptyString()) {
1568
 
    extension_ = new ::std::string;
1569
 
  }
1570
 
  extension_->assign(reinterpret_cast<const char*>(value), size);
1571
 
}
1572
 
inline ::std::string* CachedResult::mutable_extension() {
1573
 
  set_has_extension();
1574
 
  if (extension_ == &::google::protobuf::internal::GetEmptyString()) {
1575
 
    extension_ = new ::std::string;
1576
 
  }
1577
 
  return extension_;
1578
 
}
1579
 
inline ::std::string* CachedResult::release_extension() {
1580
 
  clear_has_extension();
1581
 
  if (extension_ == &::google::protobuf::internal::GetEmptyString()) {
1582
 
    return NULL;
1583
 
  } else {
1584
 
    ::std::string* temp = extension_;
1585
 
    extension_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1586
 
    return temp;
1587
 
  }
1588
 
}
1589
 
inline void CachedResult::set_allocated_extension(::std::string* extension) {
1590
 
  if (extension_ != &::google::protobuf::internal::GetEmptyString()) {
1591
 
    delete extension_;
1592
 
  }
1593
 
  if (extension) {
1594
 
    set_has_extension();
1595
 
    extension_ = extension;
1596
 
  } else {
1597
 
    clear_has_extension();
1598
 
    extension_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1599
 
  }
1600
 
}
1601
 
 
1602
 
// optional .net_instaweb.ImageDim image_file_dims = 11;
1603
 
inline bool CachedResult::has_image_file_dims() const {
1604
 
  return (_has_bits_[0] & 0x00000020u) != 0;
1605
 
}
1606
 
inline void CachedResult::set_has_image_file_dims() {
1607
 
  _has_bits_[0] |= 0x00000020u;
1608
 
}
1609
 
inline void CachedResult::clear_has_image_file_dims() {
1610
 
  _has_bits_[0] &= ~0x00000020u;
1611
 
}
1612
 
inline void CachedResult::clear_image_file_dims() {
1613
 
  if (image_file_dims_ != NULL) image_file_dims_->::net_instaweb::ImageDim::Clear();
1614
 
  clear_has_image_file_dims();
1615
 
}
1616
 
inline const ::net_instaweb::ImageDim& CachedResult::image_file_dims() const {
1617
 
  return image_file_dims_ != NULL ? *image_file_dims_ : *default_instance_->image_file_dims_;
1618
 
}
1619
 
inline ::net_instaweb::ImageDim* CachedResult::mutable_image_file_dims() {
1620
 
  set_has_image_file_dims();
1621
 
  if (image_file_dims_ == NULL) image_file_dims_ = new ::net_instaweb::ImageDim;
1622
 
  return image_file_dims_;
1623
 
}
1624
 
inline ::net_instaweb::ImageDim* CachedResult::release_image_file_dims() {
1625
 
  clear_has_image_file_dims();
1626
 
  ::net_instaweb::ImageDim* temp = image_file_dims_;
1627
 
  image_file_dims_ = NULL;
1628
 
  return temp;
1629
 
}
1630
 
inline void CachedResult::set_allocated_image_file_dims(::net_instaweb::ImageDim* image_file_dims) {
1631
 
  delete image_file_dims_;
1632
 
  image_file_dims_ = image_file_dims;
1633
 
  if (image_file_dims) {
1634
 
    set_has_image_file_dims();
1635
 
  } else {
1636
 
    clear_has_image_file_dims();
1637
 
  }
1638
 
}
1639
 
 
1640
 
// optional bytes inlined_data = 12;
1641
 
inline bool CachedResult::has_inlined_data() const {
1642
 
  return (_has_bits_[0] & 0x00000040u) != 0;
1643
 
}
1644
 
inline void CachedResult::set_has_inlined_data() {
1645
 
  _has_bits_[0] |= 0x00000040u;
1646
 
}
1647
 
inline void CachedResult::clear_has_inlined_data() {
1648
 
  _has_bits_[0] &= ~0x00000040u;
1649
 
}
1650
 
inline void CachedResult::clear_inlined_data() {
1651
 
  if (inlined_data_ != &::google::protobuf::internal::GetEmptyString()) {
1652
 
    inlined_data_->clear();
1653
 
  }
1654
 
  clear_has_inlined_data();
1655
 
}
1656
 
inline const ::std::string& CachedResult::inlined_data() const {
1657
 
  return *inlined_data_;
1658
 
}
1659
 
inline void CachedResult::set_inlined_data(const ::std::string& value) {
1660
 
  set_has_inlined_data();
1661
 
  if (inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1662
 
    inlined_data_ = new ::std::string;
1663
 
  }
1664
 
  inlined_data_->assign(value);
1665
 
}
1666
 
inline void CachedResult::set_inlined_data(const char* value) {
1667
 
  set_has_inlined_data();
1668
 
  if (inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1669
 
    inlined_data_ = new ::std::string;
1670
 
  }
1671
 
  inlined_data_->assign(value);
1672
 
}
1673
 
inline void CachedResult::set_inlined_data(const void* value, size_t size) {
1674
 
  set_has_inlined_data();
1675
 
  if (inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1676
 
    inlined_data_ = new ::std::string;
1677
 
  }
1678
 
  inlined_data_->assign(reinterpret_cast<const char*>(value), size);
1679
 
}
1680
 
inline ::std::string* CachedResult::mutable_inlined_data() {
1681
 
  set_has_inlined_data();
1682
 
  if (inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1683
 
    inlined_data_ = new ::std::string;
1684
 
  }
1685
 
  return inlined_data_;
1686
 
}
1687
 
inline ::std::string* CachedResult::release_inlined_data() {
1688
 
  clear_has_inlined_data();
1689
 
  if (inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1690
 
    return NULL;
1691
 
  } else {
1692
 
    ::std::string* temp = inlined_data_;
1693
 
    inlined_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1694
 
    return temp;
1695
 
  }
1696
 
}
1697
 
inline void CachedResult::set_allocated_inlined_data(::std::string* inlined_data) {
1698
 
  if (inlined_data_ != &::google::protobuf::internal::GetEmptyString()) {
1699
 
    delete inlined_data_;
1700
 
  }
1701
 
  if (inlined_data) {
1702
 
    set_has_inlined_data();
1703
 
    inlined_data_ = inlined_data;
1704
 
  } else {
1705
 
    clear_has_inlined_data();
1706
 
    inlined_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1707
 
  }
1708
 
}
1709
 
 
1710
 
// optional .net_instaweb.spriter.SpriterResult spriter_result = 13;
1711
 
inline bool CachedResult::has_spriter_result() const {
1712
 
  return (_has_bits_[0] & 0x00000080u) != 0;
1713
 
}
1714
 
inline void CachedResult::set_has_spriter_result() {
1715
 
  _has_bits_[0] |= 0x00000080u;
1716
 
}
1717
 
inline void CachedResult::clear_has_spriter_result() {
1718
 
  _has_bits_[0] &= ~0x00000080u;
1719
 
}
1720
 
inline void CachedResult::clear_spriter_result() {
1721
 
  if (spriter_result_ != NULL) spriter_result_->::net_instaweb::spriter::SpriterResult::Clear();
1722
 
  clear_has_spriter_result();
1723
 
}
1724
 
inline const ::net_instaweb::spriter::SpriterResult& CachedResult::spriter_result() const {
1725
 
  return spriter_result_ != NULL ? *spriter_result_ : *default_instance_->spriter_result_;
1726
 
}
1727
 
inline ::net_instaweb::spriter::SpriterResult* CachedResult::mutable_spriter_result() {
1728
 
  set_has_spriter_result();
1729
 
  if (spriter_result_ == NULL) spriter_result_ = new ::net_instaweb::spriter::SpriterResult;
1730
 
  return spriter_result_;
1731
 
}
1732
 
inline ::net_instaweb::spriter::SpriterResult* CachedResult::release_spriter_result() {
1733
 
  clear_has_spriter_result();
1734
 
  ::net_instaweb::spriter::SpriterResult* temp = spriter_result_;
1735
 
  spriter_result_ = NULL;
1736
 
  return temp;
1737
 
}
1738
 
inline void CachedResult::set_allocated_spriter_result(::net_instaweb::spriter::SpriterResult* spriter_result) {
1739
 
  delete spriter_result_;
1740
 
  spriter_result_ = spriter_result;
1741
 
  if (spriter_result) {
1742
 
    set_has_spriter_result();
1743
 
  } else {
1744
 
    clear_has_spriter_result();
1745
 
  }
1746
 
}
1747
 
 
1748
 
// repeated .net_instaweb.InputInfo input = 14;
1749
 
inline int CachedResult::input_size() const {
1750
 
  return input_.size();
1751
 
}
1752
 
inline void CachedResult::clear_input() {
1753
 
  input_.Clear();
1754
 
}
1755
 
inline const ::net_instaweb::InputInfo& CachedResult::input(int index) const {
1756
 
  return input_.Get(index);
1757
 
}
1758
 
inline ::net_instaweb::InputInfo* CachedResult::mutable_input(int index) {
1759
 
  return input_.Mutable(index);
1760
 
}
1761
 
inline ::net_instaweb::InputInfo* CachedResult::add_input() {
1762
 
  return input_.Add();
1763
 
}
1764
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >&
1765
 
CachedResult::input() const {
1766
 
  return input_;
1767
 
}
1768
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >*
1769
 
CachedResult::mutable_input() {
1770
 
  return &input_;
1771
 
}
1772
 
 
1773
 
// optional int32 inlined_image_type = 15;
1774
 
inline bool CachedResult::has_inlined_image_type() const {
1775
 
  return (_has_bits_[0] & 0x00000200u) != 0;
1776
 
}
1777
 
inline void CachedResult::set_has_inlined_image_type() {
1778
 
  _has_bits_[0] |= 0x00000200u;
1779
 
}
1780
 
inline void CachedResult::clear_has_inlined_image_type() {
1781
 
  _has_bits_[0] &= ~0x00000200u;
1782
 
}
1783
 
inline void CachedResult::clear_inlined_image_type() {
1784
 
  inlined_image_type_ = 0;
1785
 
  clear_has_inlined_image_type();
1786
 
}
1787
 
inline ::google::protobuf::int32 CachedResult::inlined_image_type() const {
1788
 
  return inlined_image_type_;
1789
 
}
1790
 
inline void CachedResult::set_inlined_image_type(::google::protobuf::int32 value) {
1791
 
  set_has_inlined_image_type();
1792
 
  inlined_image_type_ = value;
1793
 
}
1794
 
 
1795
 
// optional bytes low_resolution_inlined_data = 16;
1796
 
inline bool CachedResult::has_low_resolution_inlined_data() const {
1797
 
  return (_has_bits_[0] & 0x00000400u) != 0;
1798
 
}
1799
 
inline void CachedResult::set_has_low_resolution_inlined_data() {
1800
 
  _has_bits_[0] |= 0x00000400u;
1801
 
}
1802
 
inline void CachedResult::clear_has_low_resolution_inlined_data() {
1803
 
  _has_bits_[0] &= ~0x00000400u;
1804
 
}
1805
 
inline void CachedResult::clear_low_resolution_inlined_data() {
1806
 
  if (low_resolution_inlined_data_ != &::google::protobuf::internal::GetEmptyString()) {
1807
 
    low_resolution_inlined_data_->clear();
1808
 
  }
1809
 
  clear_has_low_resolution_inlined_data();
1810
 
}
1811
 
inline const ::std::string& CachedResult::low_resolution_inlined_data() const {
1812
 
  return *low_resolution_inlined_data_;
1813
 
}
1814
 
inline void CachedResult::set_low_resolution_inlined_data(const ::std::string& value) {
1815
 
  set_has_low_resolution_inlined_data();
1816
 
  if (low_resolution_inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1817
 
    low_resolution_inlined_data_ = new ::std::string;
1818
 
  }
1819
 
  low_resolution_inlined_data_->assign(value);
1820
 
}
1821
 
inline void CachedResult::set_low_resolution_inlined_data(const char* value) {
1822
 
  set_has_low_resolution_inlined_data();
1823
 
  if (low_resolution_inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1824
 
    low_resolution_inlined_data_ = new ::std::string;
1825
 
  }
1826
 
  low_resolution_inlined_data_->assign(value);
1827
 
}
1828
 
inline void CachedResult::set_low_resolution_inlined_data(const void* value, size_t size) {
1829
 
  set_has_low_resolution_inlined_data();
1830
 
  if (low_resolution_inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1831
 
    low_resolution_inlined_data_ = new ::std::string;
1832
 
  }
1833
 
  low_resolution_inlined_data_->assign(reinterpret_cast<const char*>(value), size);
1834
 
}
1835
 
inline ::std::string* CachedResult::mutable_low_resolution_inlined_data() {
1836
 
  set_has_low_resolution_inlined_data();
1837
 
  if (low_resolution_inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1838
 
    low_resolution_inlined_data_ = new ::std::string;
1839
 
  }
1840
 
  return low_resolution_inlined_data_;
1841
 
}
1842
 
inline ::std::string* CachedResult::release_low_resolution_inlined_data() {
1843
 
  clear_has_low_resolution_inlined_data();
1844
 
  if (low_resolution_inlined_data_ == &::google::protobuf::internal::GetEmptyString()) {
1845
 
    return NULL;
1846
 
  } else {
1847
 
    ::std::string* temp = low_resolution_inlined_data_;
1848
 
    low_resolution_inlined_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1849
 
    return temp;
1850
 
  }
1851
 
}
1852
 
inline void CachedResult::set_allocated_low_resolution_inlined_data(::std::string* low_resolution_inlined_data) {
1853
 
  if (low_resolution_inlined_data_ != &::google::protobuf::internal::GetEmptyString()) {
1854
 
    delete low_resolution_inlined_data_;
1855
 
  }
1856
 
  if (low_resolution_inlined_data) {
1857
 
    set_has_low_resolution_inlined_data();
1858
 
    low_resolution_inlined_data_ = low_resolution_inlined_data;
1859
 
  } else {
1860
 
    clear_has_low_resolution_inlined_data();
1861
 
    low_resolution_inlined_data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1862
 
  }
1863
 
}
1864
 
 
1865
 
// optional int32 low_resolution_inlined_image_type = 17;
1866
 
inline bool CachedResult::has_low_resolution_inlined_image_type() const {
1867
 
  return (_has_bits_[0] & 0x00000800u) != 0;
1868
 
}
1869
 
inline void CachedResult::set_has_low_resolution_inlined_image_type() {
1870
 
  _has_bits_[0] |= 0x00000800u;
1871
 
}
1872
 
inline void CachedResult::clear_has_low_resolution_inlined_image_type() {
1873
 
  _has_bits_[0] &= ~0x00000800u;
1874
 
}
1875
 
inline void CachedResult::clear_low_resolution_inlined_image_type() {
1876
 
  low_resolution_inlined_image_type_ = 0;
1877
 
  clear_has_low_resolution_inlined_image_type();
1878
 
}
1879
 
inline ::google::protobuf::int32 CachedResult::low_resolution_inlined_image_type() const {
1880
 
  return low_resolution_inlined_image_type_;
1881
 
}
1882
 
inline void CachedResult::set_low_resolution_inlined_image_type(::google::protobuf::int32 value) {
1883
 
  set_has_low_resolution_inlined_image_type();
1884
 
  low_resolution_inlined_image_type_ = value;
1885
 
}
1886
 
 
1887
 
// optional bool url_relocatable = 18 [default = true];
1888
 
inline bool CachedResult::has_url_relocatable() const {
1889
 
  return (_has_bits_[0] & 0x00001000u) != 0;
1890
 
}
1891
 
inline void CachedResult::set_has_url_relocatable() {
1892
 
  _has_bits_[0] |= 0x00001000u;
1893
 
}
1894
 
inline void CachedResult::clear_has_url_relocatable() {
1895
 
  _has_bits_[0] &= ~0x00001000u;
1896
 
}
1897
 
inline void CachedResult::clear_url_relocatable() {
1898
 
  url_relocatable_ = true;
1899
 
  clear_has_url_relocatable();
1900
 
}
1901
 
inline bool CachedResult::url_relocatable() const {
1902
 
  return url_relocatable_;
1903
 
}
1904
 
inline void CachedResult::set_url_relocatable(bool value) {
1905
 
  set_has_url_relocatable();
1906
 
  url_relocatable_ = value;
1907
 
}
1908
 
 
1909
 
// optional bool canonicalize_url = 19 [default = false];
1910
 
inline bool CachedResult::has_canonicalize_url() const {
1911
 
  return (_has_bits_[0] & 0x00002000u) != 0;
1912
 
}
1913
 
inline void CachedResult::set_has_canonicalize_url() {
1914
 
  _has_bits_[0] |= 0x00002000u;
1915
 
}
1916
 
inline void CachedResult::clear_has_canonicalize_url() {
1917
 
  _has_bits_[0] &= ~0x00002000u;
1918
 
}
1919
 
inline void CachedResult::clear_canonicalize_url() {
1920
 
  canonicalize_url_ = false;
1921
 
  clear_has_canonicalize_url();
1922
 
}
1923
 
inline bool CachedResult::canonicalize_url() const {
1924
 
  return canonicalize_url_;
1925
 
}
1926
 
inline void CachedResult::set_canonicalize_url(bool value) {
1927
 
  set_has_canonicalize_url();
1928
 
  canonicalize_url_ = value;
1929
 
}
1930
 
 
1931
 
// optional int64 size = 20;
1932
 
inline bool CachedResult::has_size() const {
1933
 
  return (_has_bits_[0] & 0x00004000u) != 0;
1934
 
}
1935
 
inline void CachedResult::set_has_size() {
1936
 
  _has_bits_[0] |= 0x00004000u;
1937
 
}
1938
 
inline void CachedResult::clear_has_size() {
1939
 
  _has_bits_[0] &= ~0x00004000u;
1940
 
}
1941
 
inline void CachedResult::clear_size() {
1942
 
  size_ = GOOGLE_LONGLONG(0);
1943
 
  clear_has_size();
1944
 
}
1945
 
inline ::google::protobuf::int64 CachedResult::size() const {
1946
 
  return size_;
1947
 
}
1948
 
inline void CachedResult::set_size(::google::protobuf::int64 value) {
1949
 
  set_has_size();
1950
 
  size_ = value;
1951
 
}
1952
 
 
1953
 
// repeated string debug_message = 21;
1954
 
inline int CachedResult::debug_message_size() const {
1955
 
  return debug_message_.size();
1956
 
}
1957
 
inline void CachedResult::clear_debug_message() {
1958
 
  debug_message_.Clear();
1959
 
}
1960
 
inline const ::std::string& CachedResult::debug_message(int index) const {
1961
 
  return debug_message_.Get(index);
1962
 
}
1963
 
inline ::std::string* CachedResult::mutable_debug_message(int index) {
1964
 
  return debug_message_.Mutable(index);
1965
 
}
1966
 
inline void CachedResult::set_debug_message(int index, const ::std::string& value) {
1967
 
  debug_message_.Mutable(index)->assign(value);
1968
 
}
1969
 
inline void CachedResult::set_debug_message(int index, const char* value) {
1970
 
  debug_message_.Mutable(index)->assign(value);
1971
 
}
1972
 
inline void CachedResult::set_debug_message(int index, const char* value, size_t size) {
1973
 
  debug_message_.Mutable(index)->assign(
1974
 
    reinterpret_cast<const char*>(value), size);
1975
 
}
1976
 
inline ::std::string* CachedResult::add_debug_message() {
1977
 
  return debug_message_.Add();
1978
 
}
1979
 
inline void CachedResult::add_debug_message(const ::std::string& value) {
1980
 
  debug_message_.Add()->assign(value);
1981
 
}
1982
 
inline void CachedResult::add_debug_message(const char* value) {
1983
 
  debug_message_.Add()->assign(value);
1984
 
}
1985
 
inline void CachedResult::add_debug_message(const char* value, size_t size) {
1986
 
  debug_message_.Add()->assign(reinterpret_cast<const char*>(value), size);
1987
 
}
1988
 
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
1989
 
CachedResult::debug_message() const {
1990
 
  return debug_message_;
1991
 
}
1992
 
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
1993
 
CachedResult::mutable_debug_message() {
1994
 
  return &debug_message_;
1995
 
}
1996
 
 
1997
 
// optional .net_instaweb.ResourceContext.LibWebpLevel minimal_webp_support = 22 [default = LIBWEBP_LOSSY_ONLY];
1998
 
inline bool CachedResult::has_minimal_webp_support() const {
1999
 
  return (_has_bits_[0] & 0x00010000u) != 0;
2000
 
}
2001
 
inline void CachedResult::set_has_minimal_webp_support() {
2002
 
  _has_bits_[0] |= 0x00010000u;
2003
 
}
2004
 
inline void CachedResult::clear_has_minimal_webp_support() {
2005
 
  _has_bits_[0] &= ~0x00010000u;
2006
 
}
2007
 
inline void CachedResult::clear_minimal_webp_support() {
2008
 
  minimal_webp_support_ = 1;
2009
 
  clear_has_minimal_webp_support();
2010
 
}
2011
 
inline ::net_instaweb::ResourceContext_LibWebpLevel CachedResult::minimal_webp_support() const {
2012
 
  return static_cast< ::net_instaweb::ResourceContext_LibWebpLevel >(minimal_webp_support_);
2013
 
}
2014
 
inline void CachedResult::set_minimal_webp_support(::net_instaweb::ResourceContext_LibWebpLevel value) {
2015
 
  assert(::net_instaweb::ResourceContext_LibWebpLevel_IsValid(value));
2016
 
  set_has_minimal_webp_support();
2017
 
  minimal_webp_support_ = value;
2018
 
}
2019
 
 
2020
 
// -------------------------------------------------------------------
2021
 
 
2022
 
// OutputPartitions
2023
 
 
2024
 
// repeated .net_instaweb.CachedResult partition = 1;
2025
 
inline int OutputPartitions::partition_size() const {
2026
 
  return partition_.size();
2027
 
}
2028
 
inline void OutputPartitions::clear_partition() {
2029
 
  partition_.Clear();
2030
 
}
2031
 
inline const ::net_instaweb::CachedResult& OutputPartitions::partition(int index) const {
2032
 
  return partition_.Get(index);
2033
 
}
2034
 
inline ::net_instaweb::CachedResult* OutputPartitions::mutable_partition(int index) {
2035
 
  return partition_.Mutable(index);
2036
 
}
2037
 
inline ::net_instaweb::CachedResult* OutputPartitions::add_partition() {
2038
 
  return partition_.Add();
2039
 
}
2040
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::CachedResult >&
2041
 
OutputPartitions::partition() const {
2042
 
  return partition_;
2043
 
}
2044
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::CachedResult >*
2045
 
OutputPartitions::mutable_partition() {
2046
 
  return &partition_;
2047
 
}
2048
 
 
2049
 
// repeated .net_instaweb.InputInfo other_dependency = 2;
2050
 
inline int OutputPartitions::other_dependency_size() const {
2051
 
  return other_dependency_.size();
2052
 
}
2053
 
inline void OutputPartitions::clear_other_dependency() {
2054
 
  other_dependency_.Clear();
2055
 
}
2056
 
inline const ::net_instaweb::InputInfo& OutputPartitions::other_dependency(int index) const {
2057
 
  return other_dependency_.Get(index);
2058
 
}
2059
 
inline ::net_instaweb::InputInfo* OutputPartitions::mutable_other_dependency(int index) {
2060
 
  return other_dependency_.Mutable(index);
2061
 
}
2062
 
inline ::net_instaweb::InputInfo* OutputPartitions::add_other_dependency() {
2063
 
  return other_dependency_.Add();
2064
 
}
2065
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >&
2066
 
OutputPartitions::other_dependency() const {
2067
 
  return other_dependency_;
2068
 
}
2069
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::InputInfo >*
2070
 
OutputPartitions::mutable_other_dependency() {
2071
 
  return &other_dependency_;
2072
 
}
2073
 
 
2074
 
// repeated string debug_message = 3;
2075
 
inline int OutputPartitions::debug_message_size() const {
2076
 
  return debug_message_.size();
2077
 
}
2078
 
inline void OutputPartitions::clear_debug_message() {
2079
 
  debug_message_.Clear();
2080
 
}
2081
 
inline const ::std::string& OutputPartitions::debug_message(int index) const {
2082
 
  return debug_message_.Get(index);
2083
 
}
2084
 
inline ::std::string* OutputPartitions::mutable_debug_message(int index) {
2085
 
  return debug_message_.Mutable(index);
2086
 
}
2087
 
inline void OutputPartitions::set_debug_message(int index, const ::std::string& value) {
2088
 
  debug_message_.Mutable(index)->assign(value);
2089
 
}
2090
 
inline void OutputPartitions::set_debug_message(int index, const char* value) {
2091
 
  debug_message_.Mutable(index)->assign(value);
2092
 
}
2093
 
inline void OutputPartitions::set_debug_message(int index, const char* value, size_t size) {
2094
 
  debug_message_.Mutable(index)->assign(
2095
 
    reinterpret_cast<const char*>(value), size);
2096
 
}
2097
 
inline ::std::string* OutputPartitions::add_debug_message() {
2098
 
  return debug_message_.Add();
2099
 
}
2100
 
inline void OutputPartitions::add_debug_message(const ::std::string& value) {
2101
 
  debug_message_.Add()->assign(value);
2102
 
}
2103
 
inline void OutputPartitions::add_debug_message(const char* value) {
2104
 
  debug_message_.Add()->assign(value);
2105
 
}
2106
 
inline void OutputPartitions::add_debug_message(const char* value, size_t size) {
2107
 
  debug_message_.Add()->assign(reinterpret_cast<const char*>(value), size);
2108
 
}
2109
 
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
2110
 
OutputPartitions::debug_message() const {
2111
 
  return debug_message_;
2112
 
}
2113
 
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
2114
 
OutputPartitions::mutable_debug_message() {
2115
 
  return &debug_message_;
2116
 
}
2117
 
 
2118
 
// -------------------------------------------------------------------
2119
 
 
2120
 
// ResourceContext
2121
 
 
2122
 
// optional .net_instaweb.ImageDim desired_image_dims = 1;
2123
 
inline bool ResourceContext::has_desired_image_dims() const {
2124
 
  return (_has_bits_[0] & 0x00000001u) != 0;
2125
 
}
2126
 
inline void ResourceContext::set_has_desired_image_dims() {
2127
 
  _has_bits_[0] |= 0x00000001u;
2128
 
}
2129
 
inline void ResourceContext::clear_has_desired_image_dims() {
2130
 
  _has_bits_[0] &= ~0x00000001u;
2131
 
}
2132
 
inline void ResourceContext::clear_desired_image_dims() {
2133
 
  if (desired_image_dims_ != NULL) desired_image_dims_->::net_instaweb::ImageDim::Clear();
2134
 
  clear_has_desired_image_dims();
2135
 
}
2136
 
inline const ::net_instaweb::ImageDim& ResourceContext::desired_image_dims() const {
2137
 
  return desired_image_dims_ != NULL ? *desired_image_dims_ : *default_instance_->desired_image_dims_;
2138
 
}
2139
 
inline ::net_instaweb::ImageDim* ResourceContext::mutable_desired_image_dims() {
2140
 
  set_has_desired_image_dims();
2141
 
  if (desired_image_dims_ == NULL) desired_image_dims_ = new ::net_instaweb::ImageDim;
2142
 
  return desired_image_dims_;
2143
 
}
2144
 
inline ::net_instaweb::ImageDim* ResourceContext::release_desired_image_dims() {
2145
 
  clear_has_desired_image_dims();
2146
 
  ::net_instaweb::ImageDim* temp = desired_image_dims_;
2147
 
  desired_image_dims_ = NULL;
2148
 
  return temp;
2149
 
}
2150
 
inline void ResourceContext::set_allocated_desired_image_dims(::net_instaweb::ImageDim* desired_image_dims) {
2151
 
  delete desired_image_dims_;
2152
 
  desired_image_dims_ = desired_image_dims;
2153
 
  if (desired_image_dims) {
2154
 
    set_has_desired_image_dims();
2155
 
  } else {
2156
 
    clear_has_desired_image_dims();
2157
 
  }
2158
 
}
2159
 
 
2160
 
// optional bool attempt_webp = 2 [default = false, deprecated = true];
2161
 
inline bool ResourceContext::has_attempt_webp() const {
2162
 
  return (_has_bits_[0] & 0x00000002u) != 0;
2163
 
}
2164
 
inline void ResourceContext::set_has_attempt_webp() {
2165
 
  _has_bits_[0] |= 0x00000002u;
2166
 
}
2167
 
inline void ResourceContext::clear_has_attempt_webp() {
2168
 
  _has_bits_[0] &= ~0x00000002u;
2169
 
}
2170
 
inline void ResourceContext::clear_attempt_webp() {
2171
 
  attempt_webp_ = false;
2172
 
  clear_has_attempt_webp();
2173
 
}
2174
 
inline bool ResourceContext::attempt_webp() const {
2175
 
  return attempt_webp_;
2176
 
}
2177
 
inline void ResourceContext::set_attempt_webp(bool value) {
2178
 
  set_has_attempt_webp();
2179
 
  attempt_webp_ = value;
2180
 
}
2181
 
 
2182
 
// optional bool inline_images = 3 [default = true];
2183
 
inline bool ResourceContext::has_inline_images() const {
2184
 
  return (_has_bits_[0] & 0x00000004u) != 0;
2185
 
}
2186
 
inline void ResourceContext::set_has_inline_images() {
2187
 
  _has_bits_[0] |= 0x00000004u;
2188
 
}
2189
 
inline void ResourceContext::clear_has_inline_images() {
2190
 
  _has_bits_[0] &= ~0x00000004u;
2191
 
}
2192
 
inline void ResourceContext::clear_inline_images() {
2193
 
  inline_images_ = true;
2194
 
  clear_has_inline_images();
2195
 
}
2196
 
inline bool ResourceContext::inline_images() const {
2197
 
  return inline_images_;
2198
 
}
2199
 
inline void ResourceContext::set_inline_images(bool value) {
2200
 
  set_has_inline_images();
2201
 
  inline_images_ = value;
2202
 
}
2203
 
 
2204
 
// optional bool mobile_user_agent = 4 [default = false];
2205
 
inline bool ResourceContext::has_mobile_user_agent() const {
2206
 
  return (_has_bits_[0] & 0x00000008u) != 0;
2207
 
}
2208
 
inline void ResourceContext::set_has_mobile_user_agent() {
2209
 
  _has_bits_[0] |= 0x00000008u;
2210
 
}
2211
 
inline void ResourceContext::clear_has_mobile_user_agent() {
2212
 
  _has_bits_[0] &= ~0x00000008u;
2213
 
}
2214
 
inline void ResourceContext::clear_mobile_user_agent() {
2215
 
  mobile_user_agent_ = false;
2216
 
  clear_has_mobile_user_agent();
2217
 
}
2218
 
inline bool ResourceContext::mobile_user_agent() const {
2219
 
  return mobile_user_agent_;
2220
 
}
2221
 
inline void ResourceContext::set_mobile_user_agent(bool value) {
2222
 
  set_has_mobile_user_agent();
2223
 
  mobile_user_agent_ = value;
2224
 
}
2225
 
 
2226
 
// optional .net_instaweb.ResourceContext.LibWebpLevel libwebp_level = 5 [default = LIBWEBP_NONE];
2227
 
inline bool ResourceContext::has_libwebp_level() const {
2228
 
  return (_has_bits_[0] & 0x00000010u) != 0;
2229
 
}
2230
 
inline void ResourceContext::set_has_libwebp_level() {
2231
 
  _has_bits_[0] |= 0x00000010u;
2232
 
}
2233
 
inline void ResourceContext::clear_has_libwebp_level() {
2234
 
  _has_bits_[0] &= ~0x00000010u;
2235
 
}
2236
 
inline void ResourceContext::clear_libwebp_level() {
2237
 
  libwebp_level_ = 0;
2238
 
  clear_has_libwebp_level();
2239
 
}
2240
 
inline ::net_instaweb::ResourceContext_LibWebpLevel ResourceContext::libwebp_level() const {
2241
 
  return static_cast< ::net_instaweb::ResourceContext_LibWebpLevel >(libwebp_level_);
2242
 
}
2243
 
inline void ResourceContext::set_libwebp_level(::net_instaweb::ResourceContext_LibWebpLevel value) {
2244
 
  assert(::net_instaweb::ResourceContext_LibWebpLevel_IsValid(value));
2245
 
  set_has_libwebp_level();
2246
 
  libwebp_level_ = value;
2247
 
}
2248
 
 
2249
 
// optional .net_instaweb.ImageDim user_agent_screen_resolution = 6;
2250
 
inline bool ResourceContext::has_user_agent_screen_resolution() const {
2251
 
  return (_has_bits_[0] & 0x00000020u) != 0;
2252
 
}
2253
 
inline void ResourceContext::set_has_user_agent_screen_resolution() {
2254
 
  _has_bits_[0] |= 0x00000020u;
2255
 
}
2256
 
inline void ResourceContext::clear_has_user_agent_screen_resolution() {
2257
 
  _has_bits_[0] &= ~0x00000020u;
2258
 
}
2259
 
inline void ResourceContext::clear_user_agent_screen_resolution() {
2260
 
  if (user_agent_screen_resolution_ != NULL) user_agent_screen_resolution_->::net_instaweb::ImageDim::Clear();
2261
 
  clear_has_user_agent_screen_resolution();
2262
 
}
2263
 
inline const ::net_instaweb::ImageDim& ResourceContext::user_agent_screen_resolution() const {
2264
 
  return user_agent_screen_resolution_ != NULL ? *user_agent_screen_resolution_ : *default_instance_->user_agent_screen_resolution_;
2265
 
}
2266
 
inline ::net_instaweb::ImageDim* ResourceContext::mutable_user_agent_screen_resolution() {
2267
 
  set_has_user_agent_screen_resolution();
2268
 
  if (user_agent_screen_resolution_ == NULL) user_agent_screen_resolution_ = new ::net_instaweb::ImageDim;
2269
 
  return user_agent_screen_resolution_;
2270
 
}
2271
 
inline ::net_instaweb::ImageDim* ResourceContext::release_user_agent_screen_resolution() {
2272
 
  clear_has_user_agent_screen_resolution();
2273
 
  ::net_instaweb::ImageDim* temp = user_agent_screen_resolution_;
2274
 
  user_agent_screen_resolution_ = NULL;
2275
 
  return temp;
2276
 
}
2277
 
inline void ResourceContext::set_allocated_user_agent_screen_resolution(::net_instaweb::ImageDim* user_agent_screen_resolution) {
2278
 
  delete user_agent_screen_resolution_;
2279
 
  user_agent_screen_resolution_ = user_agent_screen_resolution;
2280
 
  if (user_agent_screen_resolution) {
2281
 
    set_has_user_agent_screen_resolution();
2282
 
  } else {
2283
 
    clear_has_user_agent_screen_resolution();
2284
 
  }
2285
 
}
2286
 
 
2287
 
// optional bool use_small_screen_quality = 7 [default = false];
2288
 
inline bool ResourceContext::has_use_small_screen_quality() const {
2289
 
  return (_has_bits_[0] & 0x00000040u) != 0;
2290
 
}
2291
 
inline void ResourceContext::set_has_use_small_screen_quality() {
2292
 
  _has_bits_[0] |= 0x00000040u;
2293
 
}
2294
 
inline void ResourceContext::clear_has_use_small_screen_quality() {
2295
 
  _has_bits_[0] &= ~0x00000040u;
2296
 
}
2297
 
inline void ResourceContext::clear_use_small_screen_quality() {
2298
 
  use_small_screen_quality_ = false;
2299
 
  clear_has_use_small_screen_quality();
2300
 
}
2301
 
inline bool ResourceContext::use_small_screen_quality() const {
2302
 
  return use_small_screen_quality_;
2303
 
}
2304
 
inline void ResourceContext::set_use_small_screen_quality(bool value) {
2305
 
  set_has_use_small_screen_quality();
2306
 
  use_small_screen_quality_ = value;
2307
 
}
2308
 
 
2309
 
 
2310
 
// @@protoc_insertion_point(namespace_scope)
2311
 
 
2312
 
}  // namespace net_instaweb
2313
 
 
2314
 
#ifndef SWIG
2315
 
namespace google {
2316
 
namespace protobuf {
2317
 
 
2318
 
template <>
2319
 
inline const EnumDescriptor* GetEnumDescriptor< ::net_instaweb::InputInfo_Type>() {
2320
 
  return ::net_instaweb::InputInfo_Type_descriptor();
2321
 
}
2322
 
template <>
2323
 
inline const EnumDescriptor* GetEnumDescriptor< ::net_instaweb::ResourceContext_LibWebpLevel>() {
2324
 
  return ::net_instaweb::ResourceContext_LibWebpLevel_descriptor();
2325
 
}
2326
 
 
2327
 
}  // namespace google
2328
 
}  // namespace protobuf
2329
 
#endif  // SWIG
2330
 
 
2331
 
// @@protoc_insertion_point(global_scope)
2332
 
 
2333
 
#endif  // PROTOBUF_net_2finstaweb_2frewriter_2fcached_5fresult_2eproto__INCLUDED