← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/out/Debug/obj/gen/protoc_out/instaweb/net/instaweb/spriter/public/image_spriter.pb.h

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/out/Debug/obj/gen/protoc_out/instaweb/net/instaweb/spriter/public/image_spriter.pb.h
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
// source: net/instaweb/spriter/public/image_spriter.proto
3
 
 
4
 
#ifndef PROTOBUF_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto__INCLUDED
5
 
#define PROTOBUF_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_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
 
// @@protoc_insertion_point(includes)
30
 
 
31
 
namespace net_instaweb {
32
 
namespace spriter {
33
 
 
34
 
// Internal implementation detail -- do not call these.
35
 
void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
36
 
void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
37
 
void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
38
 
 
39
 
class Image;
40
 
class SpriteOptions;
41
 
class SpriterInput;
42
 
class Rect;
43
 
class ImagePosition;
44
 
class SpriterResult;
45
 
 
46
 
enum PlacementMethod {
47
 
  VERTICAL_STRIP = 0
48
 
};
49
 
bool PlacementMethod_IsValid(int value);
50
 
const PlacementMethod PlacementMethod_MIN = VERTICAL_STRIP;
51
 
const PlacementMethod PlacementMethod_MAX = VERTICAL_STRIP;
52
 
const int PlacementMethod_ARRAYSIZE = PlacementMethod_MAX + 1;
53
 
 
54
 
const ::google::protobuf::EnumDescriptor* PlacementMethod_descriptor();
55
 
inline const ::std::string& PlacementMethod_Name(PlacementMethod value) {
56
 
  return ::google::protobuf::internal::NameOfEnum(
57
 
    PlacementMethod_descriptor(), value);
58
 
}
59
 
inline bool PlacementMethod_Parse(
60
 
    const ::std::string& name, PlacementMethod* value) {
61
 
  return ::google::protobuf::internal::ParseNamedEnum<PlacementMethod>(
62
 
    PlacementMethod_descriptor(), name, value);
63
 
}
64
 
enum ImageFormat {
65
 
  PNG = 0,
66
 
  JPEG = 1
67
 
};
68
 
bool ImageFormat_IsValid(int value);
69
 
const ImageFormat ImageFormat_MIN = PNG;
70
 
const ImageFormat ImageFormat_MAX = JPEG;
71
 
const int ImageFormat_ARRAYSIZE = ImageFormat_MAX + 1;
72
 
 
73
 
const ::google::protobuf::EnumDescriptor* ImageFormat_descriptor();
74
 
inline const ::std::string& ImageFormat_Name(ImageFormat value) {
75
 
  return ::google::protobuf::internal::NameOfEnum(
76
 
    ImageFormat_descriptor(), value);
77
 
}
78
 
inline bool ImageFormat_Parse(
79
 
    const ::std::string& name, ImageFormat* value) {
80
 
  return ::google::protobuf::internal::ParseNamedEnum<ImageFormat>(
81
 
    ImageFormat_descriptor(), name, value);
82
 
}
83
 
// ===================================================================
84
 
 
85
 
class Image : public ::google::protobuf::Message {
86
 
 public:
87
 
  Image();
88
 
  virtual ~Image();
89
 
 
90
 
  Image(const Image& from);
91
 
 
92
 
  inline Image& operator=(const Image& from) {
93
 
    CopyFrom(from);
94
 
    return *this;
95
 
  }
96
 
 
97
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
98
 
    return _unknown_fields_;
99
 
  }
100
 
 
101
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
102
 
    return &_unknown_fields_;
103
 
  }
104
 
 
105
 
  static const ::google::protobuf::Descriptor* descriptor();
106
 
  static const Image& default_instance();
107
 
 
108
 
  void Swap(Image* other);
109
 
 
110
 
  // implements Message ----------------------------------------------
111
 
 
112
 
  Image* New() const;
113
 
  void CopyFrom(const ::google::protobuf::Message& from);
114
 
  void MergeFrom(const ::google::protobuf::Message& from);
115
 
  void CopyFrom(const Image& from);
116
 
  void MergeFrom(const Image& from);
117
 
  void Clear();
118
 
  bool IsInitialized() const;
119
 
 
120
 
  int ByteSize() const;
121
 
  bool MergePartialFromCodedStream(
122
 
      ::google::protobuf::io::CodedInputStream* input);
123
 
  void SerializeWithCachedSizes(
124
 
      ::google::protobuf::io::CodedOutputStream* output) const;
125
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
126
 
  int GetCachedSize() const { return _cached_size_; }
127
 
  private:
128
 
  void SharedCtor();
129
 
  void SharedDtor();
130
 
  void SetCachedSize(int size) const;
131
 
  public:
132
 
 
133
 
  ::google::protobuf::Metadata GetMetadata() const;
134
 
 
135
 
  // nested types ----------------------------------------------------
136
 
 
137
 
  // accessors -------------------------------------------------------
138
 
 
139
 
  // required string path = 1;
140
 
  inline bool has_path() const;
141
 
  inline void clear_path();
142
 
  static const int kPathFieldNumber = 1;
143
 
  inline const ::std::string& path() const;
144
 
  inline void set_path(const ::std::string& value);
145
 
  inline void set_path(const char* value);
146
 
  inline void set_path(const char* value, size_t size);
147
 
  inline ::std::string* mutable_path();
148
 
  inline ::std::string* release_path();
149
 
  inline void set_allocated_path(::std::string* path);
150
 
 
151
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.Image)
152
 
 private:
153
 
  inline void set_has_path();
154
 
  inline void clear_has_path();
155
 
 
156
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
157
 
 
158
 
  ::std::string* path_;
159
 
 
160
 
  mutable int _cached_size_;
161
 
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
162
 
 
163
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
164
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
165
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
166
 
 
167
 
  void InitAsDefaultInstance();
168
 
  static Image* default_instance_;
169
 
};
170
 
// -------------------------------------------------------------------
171
 
 
172
 
class SpriteOptions : public ::google::protobuf::Message {
173
 
 public:
174
 
  SpriteOptions();
175
 
  virtual ~SpriteOptions();
176
 
 
177
 
  SpriteOptions(const SpriteOptions& from);
178
 
 
179
 
  inline SpriteOptions& operator=(const SpriteOptions& from) {
180
 
    CopyFrom(from);
181
 
    return *this;
182
 
  }
183
 
 
184
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
185
 
    return _unknown_fields_;
186
 
  }
187
 
 
188
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
189
 
    return &_unknown_fields_;
190
 
  }
191
 
 
192
 
  static const ::google::protobuf::Descriptor* descriptor();
193
 
  static const SpriteOptions& default_instance();
194
 
 
195
 
  void Swap(SpriteOptions* other);
196
 
 
197
 
  // implements Message ----------------------------------------------
198
 
 
199
 
  SpriteOptions* New() const;
200
 
  void CopyFrom(const ::google::protobuf::Message& from);
201
 
  void MergeFrom(const ::google::protobuf::Message& from);
202
 
  void CopyFrom(const SpriteOptions& from);
203
 
  void MergeFrom(const SpriteOptions& from);
204
 
  void Clear();
205
 
  bool IsInitialized() const;
206
 
 
207
 
  int ByteSize() const;
208
 
  bool MergePartialFromCodedStream(
209
 
      ::google::protobuf::io::CodedInputStream* input);
210
 
  void SerializeWithCachedSizes(
211
 
      ::google::protobuf::io::CodedOutputStream* output) const;
212
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
213
 
  int GetCachedSize() const { return _cached_size_; }
214
 
  private:
215
 
  void SharedCtor();
216
 
  void SharedDtor();
217
 
  void SetCachedSize(int size) const;
218
 
  public:
219
 
 
220
 
  ::google::protobuf::Metadata GetMetadata() const;
221
 
 
222
 
  // nested types ----------------------------------------------------
223
 
 
224
 
  // accessors -------------------------------------------------------
225
 
 
226
 
  // required .net_instaweb.spriter.PlacementMethod placement_method = 1;
227
 
  inline bool has_placement_method() const;
228
 
  inline void clear_placement_method();
229
 
  static const int kPlacementMethodFieldNumber = 1;
230
 
  inline ::net_instaweb::spriter::PlacementMethod placement_method() const;
231
 
  inline void set_placement_method(::net_instaweb::spriter::PlacementMethod value);
232
 
 
233
 
  // required .net_instaweb.spriter.ImageFormat output_format = 2;
234
 
  inline bool has_output_format() const;
235
 
  inline void clear_output_format();
236
 
  static const int kOutputFormatFieldNumber = 2;
237
 
  inline ::net_instaweb::spriter::ImageFormat output_format() const;
238
 
  inline void set_output_format(::net_instaweb::spriter::ImageFormat value);
239
 
 
240
 
  // required string input_base_path = 3;
241
 
  inline bool has_input_base_path() const;
242
 
  inline void clear_input_base_path();
243
 
  static const int kInputBasePathFieldNumber = 3;
244
 
  inline const ::std::string& input_base_path() const;
245
 
  inline void set_input_base_path(const ::std::string& value);
246
 
  inline void set_input_base_path(const char* value);
247
 
  inline void set_input_base_path(const char* value, size_t size);
248
 
  inline ::std::string* mutable_input_base_path();
249
 
  inline ::std::string* release_input_base_path();
250
 
  inline void set_allocated_input_base_path(::std::string* input_base_path);
251
 
 
252
 
  // required string output_base_path = 4;
253
 
  inline bool has_output_base_path() const;
254
 
  inline void clear_output_base_path();
255
 
  static const int kOutputBasePathFieldNumber = 4;
256
 
  inline const ::std::string& output_base_path() const;
257
 
  inline void set_output_base_path(const ::std::string& value);
258
 
  inline void set_output_base_path(const char* value);
259
 
  inline void set_output_base_path(const char* value, size_t size);
260
 
  inline ::std::string* mutable_output_base_path();
261
 
  inline ::std::string* release_output_base_path();
262
 
  inline void set_allocated_output_base_path(::std::string* output_base_path);
263
 
 
264
 
  // required string output_image_path = 5;
265
 
  inline bool has_output_image_path() const;
266
 
  inline void clear_output_image_path();
267
 
  static const int kOutputImagePathFieldNumber = 5;
268
 
  inline const ::std::string& output_image_path() const;
269
 
  inline void set_output_image_path(const ::std::string& value);
270
 
  inline void set_output_image_path(const char* value);
271
 
  inline void set_output_image_path(const char* value, size_t size);
272
 
  inline ::std::string* mutable_output_image_path();
273
 
  inline ::std::string* release_output_image_path();
274
 
  inline void set_allocated_output_image_path(::std::string* output_image_path);
275
 
 
276
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.SpriteOptions)
277
 
 private:
278
 
  inline void set_has_placement_method();
279
 
  inline void clear_has_placement_method();
280
 
  inline void set_has_output_format();
281
 
  inline void clear_has_output_format();
282
 
  inline void set_has_input_base_path();
283
 
  inline void clear_has_input_base_path();
284
 
  inline void set_has_output_base_path();
285
 
  inline void clear_has_output_base_path();
286
 
  inline void set_has_output_image_path();
287
 
  inline void clear_has_output_image_path();
288
 
 
289
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
290
 
 
291
 
  int placement_method_;
292
 
  int output_format_;
293
 
  ::std::string* input_base_path_;
294
 
  ::std::string* output_base_path_;
295
 
  ::std::string* output_image_path_;
296
 
 
297
 
  mutable int _cached_size_;
298
 
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
299
 
 
300
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
301
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
302
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
303
 
 
304
 
  void InitAsDefaultInstance();
305
 
  static SpriteOptions* default_instance_;
306
 
};
307
 
// -------------------------------------------------------------------
308
 
 
309
 
class SpriterInput : public ::google::protobuf::Message {
310
 
 public:
311
 
  SpriterInput();
312
 
  virtual ~SpriterInput();
313
 
 
314
 
  SpriterInput(const SpriterInput& from);
315
 
 
316
 
  inline SpriterInput& operator=(const SpriterInput& from) {
317
 
    CopyFrom(from);
318
 
    return *this;
319
 
  }
320
 
 
321
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
322
 
    return _unknown_fields_;
323
 
  }
324
 
 
325
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
326
 
    return &_unknown_fields_;
327
 
  }
328
 
 
329
 
  static const ::google::protobuf::Descriptor* descriptor();
330
 
  static const SpriterInput& default_instance();
331
 
 
332
 
  void Swap(SpriterInput* other);
333
 
 
334
 
  // implements Message ----------------------------------------------
335
 
 
336
 
  SpriterInput* New() const;
337
 
  void CopyFrom(const ::google::protobuf::Message& from);
338
 
  void MergeFrom(const ::google::protobuf::Message& from);
339
 
  void CopyFrom(const SpriterInput& from);
340
 
  void MergeFrom(const SpriterInput& from);
341
 
  void Clear();
342
 
  bool IsInitialized() const;
343
 
 
344
 
  int ByteSize() const;
345
 
  bool MergePartialFromCodedStream(
346
 
      ::google::protobuf::io::CodedInputStream* input);
347
 
  void SerializeWithCachedSizes(
348
 
      ::google::protobuf::io::CodedOutputStream* output) const;
349
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
350
 
  int GetCachedSize() const { return _cached_size_; }
351
 
  private:
352
 
  void SharedCtor();
353
 
  void SharedDtor();
354
 
  void SetCachedSize(int size) const;
355
 
  public:
356
 
 
357
 
  ::google::protobuf::Metadata GetMetadata() const;
358
 
 
359
 
  // nested types ----------------------------------------------------
360
 
 
361
 
  // accessors -------------------------------------------------------
362
 
 
363
 
  // optional int32 id = 1 [default = 0];
364
 
  inline bool has_id() const;
365
 
  inline void clear_id();
366
 
  static const int kIdFieldNumber = 1;
367
 
  inline ::google::protobuf::int32 id() const;
368
 
  inline void set_id(::google::protobuf::int32 value);
369
 
 
370
 
  // required .net_instaweb.spriter.SpriteOptions options = 2;
371
 
  inline bool has_options() const;
372
 
  inline void clear_options();
373
 
  static const int kOptionsFieldNumber = 2;
374
 
  inline const ::net_instaweb::spriter::SpriteOptions& options() const;
375
 
  inline ::net_instaweb::spriter::SpriteOptions* mutable_options();
376
 
  inline ::net_instaweb::spriter::SpriteOptions* release_options();
377
 
  inline void set_allocated_options(::net_instaweb::spriter::SpriteOptions* options);
378
 
 
379
 
  // repeated .net_instaweb.spriter.Image input_image_set = 3;
380
 
  inline int input_image_set_size() const;
381
 
  inline void clear_input_image_set();
382
 
  static const int kInputImageSetFieldNumber = 3;
383
 
  inline const ::net_instaweb::spriter::Image& input_image_set(int index) const;
384
 
  inline ::net_instaweb::spriter::Image* mutable_input_image_set(int index);
385
 
  inline ::net_instaweb::spriter::Image* add_input_image_set();
386
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::Image >&
387
 
      input_image_set() const;
388
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::Image >*
389
 
      mutable_input_image_set();
390
 
 
391
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.SpriterInput)
392
 
 private:
393
 
  inline void set_has_id();
394
 
  inline void clear_has_id();
395
 
  inline void set_has_options();
396
 
  inline void clear_has_options();
397
 
 
398
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
399
 
 
400
 
  ::net_instaweb::spriter::SpriteOptions* options_;
401
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::Image > input_image_set_;
402
 
  ::google::protobuf::int32 id_;
403
 
 
404
 
  mutable int _cached_size_;
405
 
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
406
 
 
407
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
408
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
409
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
410
 
 
411
 
  void InitAsDefaultInstance();
412
 
  static SpriterInput* default_instance_;
413
 
};
414
 
// -------------------------------------------------------------------
415
 
 
416
 
class Rect : public ::google::protobuf::Message {
417
 
 public:
418
 
  Rect();
419
 
  virtual ~Rect();
420
 
 
421
 
  Rect(const Rect& from);
422
 
 
423
 
  inline Rect& operator=(const Rect& from) {
424
 
    CopyFrom(from);
425
 
    return *this;
426
 
  }
427
 
 
428
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
429
 
    return _unknown_fields_;
430
 
  }
431
 
 
432
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
433
 
    return &_unknown_fields_;
434
 
  }
435
 
 
436
 
  static const ::google::protobuf::Descriptor* descriptor();
437
 
  static const Rect& default_instance();
438
 
 
439
 
  void Swap(Rect* other);
440
 
 
441
 
  // implements Message ----------------------------------------------
442
 
 
443
 
  Rect* New() const;
444
 
  void CopyFrom(const ::google::protobuf::Message& from);
445
 
  void MergeFrom(const ::google::protobuf::Message& from);
446
 
  void CopyFrom(const Rect& from);
447
 
  void MergeFrom(const Rect& from);
448
 
  void Clear();
449
 
  bool IsInitialized() const;
450
 
 
451
 
  int ByteSize() const;
452
 
  bool MergePartialFromCodedStream(
453
 
      ::google::protobuf::io::CodedInputStream* input);
454
 
  void SerializeWithCachedSizes(
455
 
      ::google::protobuf::io::CodedOutputStream* output) const;
456
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
457
 
  int GetCachedSize() const { return _cached_size_; }
458
 
  private:
459
 
  void SharedCtor();
460
 
  void SharedDtor();
461
 
  void SetCachedSize(int size) const;
462
 
  public:
463
 
 
464
 
  ::google::protobuf::Metadata GetMetadata() const;
465
 
 
466
 
  // nested types ----------------------------------------------------
467
 
 
468
 
  // accessors -------------------------------------------------------
469
 
 
470
 
  // required int32 x_pos = 1;
471
 
  inline bool has_x_pos() const;
472
 
  inline void clear_x_pos();
473
 
  static const int kXPosFieldNumber = 1;
474
 
  inline ::google::protobuf::int32 x_pos() const;
475
 
  inline void set_x_pos(::google::protobuf::int32 value);
476
 
 
477
 
  // required int32 y_pos = 2;
478
 
  inline bool has_y_pos() const;
479
 
  inline void clear_y_pos();
480
 
  static const int kYPosFieldNumber = 2;
481
 
  inline ::google::protobuf::int32 y_pos() const;
482
 
  inline void set_y_pos(::google::protobuf::int32 value);
483
 
 
484
 
  // required int32 width = 3;
485
 
  inline bool has_width() const;
486
 
  inline void clear_width();
487
 
  static const int kWidthFieldNumber = 3;
488
 
  inline ::google::protobuf::int32 width() const;
489
 
  inline void set_width(::google::protobuf::int32 value);
490
 
 
491
 
  // required int32 height = 4;
492
 
  inline bool has_height() const;
493
 
  inline void clear_height();
494
 
  static const int kHeightFieldNumber = 4;
495
 
  inline ::google::protobuf::int32 height() const;
496
 
  inline void set_height(::google::protobuf::int32 value);
497
 
 
498
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.Rect)
499
 
 private:
500
 
  inline void set_has_x_pos();
501
 
  inline void clear_has_x_pos();
502
 
  inline void set_has_y_pos();
503
 
  inline void clear_has_y_pos();
504
 
  inline void set_has_width();
505
 
  inline void clear_has_width();
506
 
  inline void set_has_height();
507
 
  inline void clear_has_height();
508
 
 
509
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
510
 
 
511
 
  ::google::protobuf::int32 x_pos_;
512
 
  ::google::protobuf::int32 y_pos_;
513
 
  ::google::protobuf::int32 width_;
514
 
  ::google::protobuf::int32 height_;
515
 
 
516
 
  mutable int _cached_size_;
517
 
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
518
 
 
519
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
520
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
521
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
522
 
 
523
 
  void InitAsDefaultInstance();
524
 
  static Rect* default_instance_;
525
 
};
526
 
// -------------------------------------------------------------------
527
 
 
528
 
class ImagePosition : public ::google::protobuf::Message {
529
 
 public:
530
 
  ImagePosition();
531
 
  virtual ~ImagePosition();
532
 
 
533
 
  ImagePosition(const ImagePosition& from);
534
 
 
535
 
  inline ImagePosition& operator=(const ImagePosition& from) {
536
 
    CopyFrom(from);
537
 
    return *this;
538
 
  }
539
 
 
540
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
541
 
    return _unknown_fields_;
542
 
  }
543
 
 
544
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
545
 
    return &_unknown_fields_;
546
 
  }
547
 
 
548
 
  static const ::google::protobuf::Descriptor* descriptor();
549
 
  static const ImagePosition& default_instance();
550
 
 
551
 
  void Swap(ImagePosition* other);
552
 
 
553
 
  // implements Message ----------------------------------------------
554
 
 
555
 
  ImagePosition* New() const;
556
 
  void CopyFrom(const ::google::protobuf::Message& from);
557
 
  void MergeFrom(const ::google::protobuf::Message& from);
558
 
  void CopyFrom(const ImagePosition& from);
559
 
  void MergeFrom(const ImagePosition& from);
560
 
  void Clear();
561
 
  bool IsInitialized() const;
562
 
 
563
 
  int ByteSize() const;
564
 
  bool MergePartialFromCodedStream(
565
 
      ::google::protobuf::io::CodedInputStream* input);
566
 
  void SerializeWithCachedSizes(
567
 
      ::google::protobuf::io::CodedOutputStream* output) const;
568
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
569
 
  int GetCachedSize() const { return _cached_size_; }
570
 
  private:
571
 
  void SharedCtor();
572
 
  void SharedDtor();
573
 
  void SetCachedSize(int size) const;
574
 
  public:
575
 
 
576
 
  ::google::protobuf::Metadata GetMetadata() const;
577
 
 
578
 
  // nested types ----------------------------------------------------
579
 
 
580
 
  // accessors -------------------------------------------------------
581
 
 
582
 
  // required string path = 1;
583
 
  inline bool has_path() const;
584
 
  inline void clear_path();
585
 
  static const int kPathFieldNumber = 1;
586
 
  inline const ::std::string& path() const;
587
 
  inline void set_path(const ::std::string& value);
588
 
  inline void set_path(const char* value);
589
 
  inline void set_path(const char* value, size_t size);
590
 
  inline ::std::string* mutable_path();
591
 
  inline ::std::string* release_path();
592
 
  inline void set_allocated_path(::std::string* path);
593
 
 
594
 
  // required .net_instaweb.spriter.Rect clip_rect = 2;
595
 
  inline bool has_clip_rect() const;
596
 
  inline void clear_clip_rect();
597
 
  static const int kClipRectFieldNumber = 2;
598
 
  inline const ::net_instaweb::spriter::Rect& clip_rect() const;
599
 
  inline ::net_instaweb::spriter::Rect* mutable_clip_rect();
600
 
  inline ::net_instaweb::spriter::Rect* release_clip_rect();
601
 
  inline void set_allocated_clip_rect(::net_instaweb::spriter::Rect* clip_rect);
602
 
 
603
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.ImagePosition)
604
 
 private:
605
 
  inline void set_has_path();
606
 
  inline void clear_has_path();
607
 
  inline void set_has_clip_rect();
608
 
  inline void clear_has_clip_rect();
609
 
 
610
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
611
 
 
612
 
  ::std::string* path_;
613
 
  ::net_instaweb::spriter::Rect* clip_rect_;
614
 
 
615
 
  mutable int _cached_size_;
616
 
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
617
 
 
618
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
619
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
620
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
621
 
 
622
 
  void InitAsDefaultInstance();
623
 
  static ImagePosition* default_instance_;
624
 
};
625
 
// -------------------------------------------------------------------
626
 
 
627
 
class SpriterResult : public ::google::protobuf::Message {
628
 
 public:
629
 
  SpriterResult();
630
 
  virtual ~SpriterResult();
631
 
 
632
 
  SpriterResult(const SpriterResult& from);
633
 
 
634
 
  inline SpriterResult& operator=(const SpriterResult& from) {
635
 
    CopyFrom(from);
636
 
    return *this;
637
 
  }
638
 
 
639
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
640
 
    return _unknown_fields_;
641
 
  }
642
 
 
643
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
644
 
    return &_unknown_fields_;
645
 
  }
646
 
 
647
 
  static const ::google::protobuf::Descriptor* descriptor();
648
 
  static const SpriterResult& default_instance();
649
 
 
650
 
  void Swap(SpriterResult* other);
651
 
 
652
 
  // implements Message ----------------------------------------------
653
 
 
654
 
  SpriterResult* New() const;
655
 
  void CopyFrom(const ::google::protobuf::Message& from);
656
 
  void MergeFrom(const ::google::protobuf::Message& from);
657
 
  void CopyFrom(const SpriterResult& from);
658
 
  void MergeFrom(const SpriterResult& from);
659
 
  void Clear();
660
 
  bool IsInitialized() const;
661
 
 
662
 
  int ByteSize() const;
663
 
  bool MergePartialFromCodedStream(
664
 
      ::google::protobuf::io::CodedInputStream* input);
665
 
  void SerializeWithCachedSizes(
666
 
      ::google::protobuf::io::CodedOutputStream* output) const;
667
 
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
668
 
  int GetCachedSize() const { return _cached_size_; }
669
 
  private:
670
 
  void SharedCtor();
671
 
  void SharedDtor();
672
 
  void SetCachedSize(int size) const;
673
 
  public:
674
 
 
675
 
  ::google::protobuf::Metadata GetMetadata() const;
676
 
 
677
 
  // nested types ----------------------------------------------------
678
 
 
679
 
  // accessors -------------------------------------------------------
680
 
 
681
 
  // required int32 id = 1;
682
 
  inline bool has_id() const;
683
 
  inline void clear_id();
684
 
  static const int kIdFieldNumber = 1;
685
 
  inline ::google::protobuf::int32 id() const;
686
 
  inline void set_id(::google::protobuf::int32 value);
687
 
 
688
 
  // required string output_base_path = 2;
689
 
  inline bool has_output_base_path() const;
690
 
  inline void clear_output_base_path();
691
 
  static const int kOutputBasePathFieldNumber = 2;
692
 
  inline const ::std::string& output_base_path() const;
693
 
  inline void set_output_base_path(const ::std::string& value);
694
 
  inline void set_output_base_path(const char* value);
695
 
  inline void set_output_base_path(const char* value, size_t size);
696
 
  inline ::std::string* mutable_output_base_path();
697
 
  inline ::std::string* release_output_base_path();
698
 
  inline void set_allocated_output_base_path(::std::string* output_base_path);
699
 
 
700
 
  // required string output_image_path = 3;
701
 
  inline bool has_output_image_path() const;
702
 
  inline void clear_output_image_path();
703
 
  static const int kOutputImagePathFieldNumber = 3;
704
 
  inline const ::std::string& output_image_path() const;
705
 
  inline void set_output_image_path(const ::std::string& value);
706
 
  inline void set_output_image_path(const char* value);
707
 
  inline void set_output_image_path(const char* value, size_t size);
708
 
  inline ::std::string* mutable_output_image_path();
709
 
  inline ::std::string* release_output_image_path();
710
 
  inline void set_allocated_output_image_path(::std::string* output_image_path);
711
 
 
712
 
  // repeated .net_instaweb.spriter.ImagePosition image_position = 4;
713
 
  inline int image_position_size() const;
714
 
  inline void clear_image_position();
715
 
  static const int kImagePositionFieldNumber = 4;
716
 
  inline const ::net_instaweb::spriter::ImagePosition& image_position(int index) const;
717
 
  inline ::net_instaweb::spriter::ImagePosition* mutable_image_position(int index);
718
 
  inline ::net_instaweb::spriter::ImagePosition* add_image_position();
719
 
  inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::ImagePosition >&
720
 
      image_position() const;
721
 
  inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::ImagePosition >*
722
 
      mutable_image_position();
723
 
 
724
 
  // @@protoc_insertion_point(class_scope:net_instaweb.spriter.SpriterResult)
725
 
 private:
726
 
  inline void set_has_id();
727
 
  inline void clear_has_id();
728
 
  inline void set_has_output_base_path();
729
 
  inline void clear_has_output_base_path();
730
 
  inline void set_has_output_image_path();
731
 
  inline void clear_has_output_image_path();
732
 
 
733
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
734
 
 
735
 
  ::std::string* output_base_path_;
736
 
  ::std::string* output_image_path_;
737
 
  ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::ImagePosition > image_position_;
738
 
  ::google::protobuf::int32 id_;
739
 
 
740
 
  mutable int _cached_size_;
741
 
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
742
 
 
743
 
  friend void  protobuf_AddDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
744
 
  friend void protobuf_AssignDesc_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
745
 
  friend void protobuf_ShutdownFile_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto();
746
 
 
747
 
  void InitAsDefaultInstance();
748
 
  static SpriterResult* default_instance_;
749
 
};
750
 
// ===================================================================
751
 
 
752
 
 
753
 
// ===================================================================
754
 
 
755
 
// Image
756
 
 
757
 
// required string path = 1;
758
 
inline bool Image::has_path() const {
759
 
  return (_has_bits_[0] & 0x00000001u) != 0;
760
 
}
761
 
inline void Image::set_has_path() {
762
 
  _has_bits_[0] |= 0x00000001u;
763
 
}
764
 
inline void Image::clear_has_path() {
765
 
  _has_bits_[0] &= ~0x00000001u;
766
 
}
767
 
inline void Image::clear_path() {
768
 
  if (path_ != &::google::protobuf::internal::GetEmptyString()) {
769
 
    path_->clear();
770
 
  }
771
 
  clear_has_path();
772
 
}
773
 
inline const ::std::string& Image::path() const {
774
 
  return *path_;
775
 
}
776
 
inline void Image::set_path(const ::std::string& value) {
777
 
  set_has_path();
778
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
779
 
    path_ = new ::std::string;
780
 
  }
781
 
  path_->assign(value);
782
 
}
783
 
inline void Image::set_path(const char* value) {
784
 
  set_has_path();
785
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
786
 
    path_ = new ::std::string;
787
 
  }
788
 
  path_->assign(value);
789
 
}
790
 
inline void Image::set_path(const char* value, size_t size) {
791
 
  set_has_path();
792
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
793
 
    path_ = new ::std::string;
794
 
  }
795
 
  path_->assign(reinterpret_cast<const char*>(value), size);
796
 
}
797
 
inline ::std::string* Image::mutable_path() {
798
 
  set_has_path();
799
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
800
 
    path_ = new ::std::string;
801
 
  }
802
 
  return path_;
803
 
}
804
 
inline ::std::string* Image::release_path() {
805
 
  clear_has_path();
806
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
807
 
    return NULL;
808
 
  } else {
809
 
    ::std::string* temp = path_;
810
 
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
811
 
    return temp;
812
 
  }
813
 
}
814
 
inline void Image::set_allocated_path(::std::string* path) {
815
 
  if (path_ != &::google::protobuf::internal::GetEmptyString()) {
816
 
    delete path_;
817
 
  }
818
 
  if (path) {
819
 
    set_has_path();
820
 
    path_ = path;
821
 
  } else {
822
 
    clear_has_path();
823
 
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
824
 
  }
825
 
}
826
 
 
827
 
// -------------------------------------------------------------------
828
 
 
829
 
// SpriteOptions
830
 
 
831
 
// required .net_instaweb.spriter.PlacementMethod placement_method = 1;
832
 
inline bool SpriteOptions::has_placement_method() const {
833
 
  return (_has_bits_[0] & 0x00000001u) != 0;
834
 
}
835
 
inline void SpriteOptions::set_has_placement_method() {
836
 
  _has_bits_[0] |= 0x00000001u;
837
 
}
838
 
inline void SpriteOptions::clear_has_placement_method() {
839
 
  _has_bits_[0] &= ~0x00000001u;
840
 
}
841
 
inline void SpriteOptions::clear_placement_method() {
842
 
  placement_method_ = 0;
843
 
  clear_has_placement_method();
844
 
}
845
 
inline ::net_instaweb::spriter::PlacementMethod SpriteOptions::placement_method() const {
846
 
  return static_cast< ::net_instaweb::spriter::PlacementMethod >(placement_method_);
847
 
}
848
 
inline void SpriteOptions::set_placement_method(::net_instaweb::spriter::PlacementMethod value) {
849
 
  assert(::net_instaweb::spriter::PlacementMethod_IsValid(value));
850
 
  set_has_placement_method();
851
 
  placement_method_ = value;
852
 
}
853
 
 
854
 
// required .net_instaweb.spriter.ImageFormat output_format = 2;
855
 
inline bool SpriteOptions::has_output_format() const {
856
 
  return (_has_bits_[0] & 0x00000002u) != 0;
857
 
}
858
 
inline void SpriteOptions::set_has_output_format() {
859
 
  _has_bits_[0] |= 0x00000002u;
860
 
}
861
 
inline void SpriteOptions::clear_has_output_format() {
862
 
  _has_bits_[0] &= ~0x00000002u;
863
 
}
864
 
inline void SpriteOptions::clear_output_format() {
865
 
  output_format_ = 0;
866
 
  clear_has_output_format();
867
 
}
868
 
inline ::net_instaweb::spriter::ImageFormat SpriteOptions::output_format() const {
869
 
  return static_cast< ::net_instaweb::spriter::ImageFormat >(output_format_);
870
 
}
871
 
inline void SpriteOptions::set_output_format(::net_instaweb::spriter::ImageFormat value) {
872
 
  assert(::net_instaweb::spriter::ImageFormat_IsValid(value));
873
 
  set_has_output_format();
874
 
  output_format_ = value;
875
 
}
876
 
 
877
 
// required string input_base_path = 3;
878
 
inline bool SpriteOptions::has_input_base_path() const {
879
 
  return (_has_bits_[0] & 0x00000004u) != 0;
880
 
}
881
 
inline void SpriteOptions::set_has_input_base_path() {
882
 
  _has_bits_[0] |= 0x00000004u;
883
 
}
884
 
inline void SpriteOptions::clear_has_input_base_path() {
885
 
  _has_bits_[0] &= ~0x00000004u;
886
 
}
887
 
inline void SpriteOptions::clear_input_base_path() {
888
 
  if (input_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
889
 
    input_base_path_->clear();
890
 
  }
891
 
  clear_has_input_base_path();
892
 
}
893
 
inline const ::std::string& SpriteOptions::input_base_path() const {
894
 
  return *input_base_path_;
895
 
}
896
 
inline void SpriteOptions::set_input_base_path(const ::std::string& value) {
897
 
  set_has_input_base_path();
898
 
  if (input_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
899
 
    input_base_path_ = new ::std::string;
900
 
  }
901
 
  input_base_path_->assign(value);
902
 
}
903
 
inline void SpriteOptions::set_input_base_path(const char* value) {
904
 
  set_has_input_base_path();
905
 
  if (input_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
906
 
    input_base_path_ = new ::std::string;
907
 
  }
908
 
  input_base_path_->assign(value);
909
 
}
910
 
inline void SpriteOptions::set_input_base_path(const char* value, size_t size) {
911
 
  set_has_input_base_path();
912
 
  if (input_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
913
 
    input_base_path_ = new ::std::string;
914
 
  }
915
 
  input_base_path_->assign(reinterpret_cast<const char*>(value), size);
916
 
}
917
 
inline ::std::string* SpriteOptions::mutable_input_base_path() {
918
 
  set_has_input_base_path();
919
 
  if (input_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
920
 
    input_base_path_ = new ::std::string;
921
 
  }
922
 
  return input_base_path_;
923
 
}
924
 
inline ::std::string* SpriteOptions::release_input_base_path() {
925
 
  clear_has_input_base_path();
926
 
  if (input_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
927
 
    return NULL;
928
 
  } else {
929
 
    ::std::string* temp = input_base_path_;
930
 
    input_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
931
 
    return temp;
932
 
  }
933
 
}
934
 
inline void SpriteOptions::set_allocated_input_base_path(::std::string* input_base_path) {
935
 
  if (input_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
936
 
    delete input_base_path_;
937
 
  }
938
 
  if (input_base_path) {
939
 
    set_has_input_base_path();
940
 
    input_base_path_ = input_base_path;
941
 
  } else {
942
 
    clear_has_input_base_path();
943
 
    input_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
944
 
  }
945
 
}
946
 
 
947
 
// required string output_base_path = 4;
948
 
inline bool SpriteOptions::has_output_base_path() const {
949
 
  return (_has_bits_[0] & 0x00000008u) != 0;
950
 
}
951
 
inline void SpriteOptions::set_has_output_base_path() {
952
 
  _has_bits_[0] |= 0x00000008u;
953
 
}
954
 
inline void SpriteOptions::clear_has_output_base_path() {
955
 
  _has_bits_[0] &= ~0x00000008u;
956
 
}
957
 
inline void SpriteOptions::clear_output_base_path() {
958
 
  if (output_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
959
 
    output_base_path_->clear();
960
 
  }
961
 
  clear_has_output_base_path();
962
 
}
963
 
inline const ::std::string& SpriteOptions::output_base_path() const {
964
 
  return *output_base_path_;
965
 
}
966
 
inline void SpriteOptions::set_output_base_path(const ::std::string& value) {
967
 
  set_has_output_base_path();
968
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
969
 
    output_base_path_ = new ::std::string;
970
 
  }
971
 
  output_base_path_->assign(value);
972
 
}
973
 
inline void SpriteOptions::set_output_base_path(const char* value) {
974
 
  set_has_output_base_path();
975
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
976
 
    output_base_path_ = new ::std::string;
977
 
  }
978
 
  output_base_path_->assign(value);
979
 
}
980
 
inline void SpriteOptions::set_output_base_path(const char* value, size_t size) {
981
 
  set_has_output_base_path();
982
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
983
 
    output_base_path_ = new ::std::string;
984
 
  }
985
 
  output_base_path_->assign(reinterpret_cast<const char*>(value), size);
986
 
}
987
 
inline ::std::string* SpriteOptions::mutable_output_base_path() {
988
 
  set_has_output_base_path();
989
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
990
 
    output_base_path_ = new ::std::string;
991
 
  }
992
 
  return output_base_path_;
993
 
}
994
 
inline ::std::string* SpriteOptions::release_output_base_path() {
995
 
  clear_has_output_base_path();
996
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
997
 
    return NULL;
998
 
  } else {
999
 
    ::std::string* temp = output_base_path_;
1000
 
    output_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1001
 
    return temp;
1002
 
  }
1003
 
}
1004
 
inline void SpriteOptions::set_allocated_output_base_path(::std::string* output_base_path) {
1005
 
  if (output_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
1006
 
    delete output_base_path_;
1007
 
  }
1008
 
  if (output_base_path) {
1009
 
    set_has_output_base_path();
1010
 
    output_base_path_ = output_base_path;
1011
 
  } else {
1012
 
    clear_has_output_base_path();
1013
 
    output_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1014
 
  }
1015
 
}
1016
 
 
1017
 
// required string output_image_path = 5;
1018
 
inline bool SpriteOptions::has_output_image_path() const {
1019
 
  return (_has_bits_[0] & 0x00000010u) != 0;
1020
 
}
1021
 
inline void SpriteOptions::set_has_output_image_path() {
1022
 
  _has_bits_[0] |= 0x00000010u;
1023
 
}
1024
 
inline void SpriteOptions::clear_has_output_image_path() {
1025
 
  _has_bits_[0] &= ~0x00000010u;
1026
 
}
1027
 
inline void SpriteOptions::clear_output_image_path() {
1028
 
  if (output_image_path_ != &::google::protobuf::internal::GetEmptyString()) {
1029
 
    output_image_path_->clear();
1030
 
  }
1031
 
  clear_has_output_image_path();
1032
 
}
1033
 
inline const ::std::string& SpriteOptions::output_image_path() const {
1034
 
  return *output_image_path_;
1035
 
}
1036
 
inline void SpriteOptions::set_output_image_path(const ::std::string& value) {
1037
 
  set_has_output_image_path();
1038
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1039
 
    output_image_path_ = new ::std::string;
1040
 
  }
1041
 
  output_image_path_->assign(value);
1042
 
}
1043
 
inline void SpriteOptions::set_output_image_path(const char* value) {
1044
 
  set_has_output_image_path();
1045
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1046
 
    output_image_path_ = new ::std::string;
1047
 
  }
1048
 
  output_image_path_->assign(value);
1049
 
}
1050
 
inline void SpriteOptions::set_output_image_path(const char* value, size_t size) {
1051
 
  set_has_output_image_path();
1052
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1053
 
    output_image_path_ = new ::std::string;
1054
 
  }
1055
 
  output_image_path_->assign(reinterpret_cast<const char*>(value), size);
1056
 
}
1057
 
inline ::std::string* SpriteOptions::mutable_output_image_path() {
1058
 
  set_has_output_image_path();
1059
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1060
 
    output_image_path_ = new ::std::string;
1061
 
  }
1062
 
  return output_image_path_;
1063
 
}
1064
 
inline ::std::string* SpriteOptions::release_output_image_path() {
1065
 
  clear_has_output_image_path();
1066
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1067
 
    return NULL;
1068
 
  } else {
1069
 
    ::std::string* temp = output_image_path_;
1070
 
    output_image_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1071
 
    return temp;
1072
 
  }
1073
 
}
1074
 
inline void SpriteOptions::set_allocated_output_image_path(::std::string* output_image_path) {
1075
 
  if (output_image_path_ != &::google::protobuf::internal::GetEmptyString()) {
1076
 
    delete output_image_path_;
1077
 
  }
1078
 
  if (output_image_path) {
1079
 
    set_has_output_image_path();
1080
 
    output_image_path_ = output_image_path;
1081
 
  } else {
1082
 
    clear_has_output_image_path();
1083
 
    output_image_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1084
 
  }
1085
 
}
1086
 
 
1087
 
// -------------------------------------------------------------------
1088
 
 
1089
 
// SpriterInput
1090
 
 
1091
 
// optional int32 id = 1 [default = 0];
1092
 
inline bool SpriterInput::has_id() const {
1093
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1094
 
}
1095
 
inline void SpriterInput::set_has_id() {
1096
 
  _has_bits_[0] |= 0x00000001u;
1097
 
}
1098
 
inline void SpriterInput::clear_has_id() {
1099
 
  _has_bits_[0] &= ~0x00000001u;
1100
 
}
1101
 
inline void SpriterInput::clear_id() {
1102
 
  id_ = 0;
1103
 
  clear_has_id();
1104
 
}
1105
 
inline ::google::protobuf::int32 SpriterInput::id() const {
1106
 
  return id_;
1107
 
}
1108
 
inline void SpriterInput::set_id(::google::protobuf::int32 value) {
1109
 
  set_has_id();
1110
 
  id_ = value;
1111
 
}
1112
 
 
1113
 
// required .net_instaweb.spriter.SpriteOptions options = 2;
1114
 
inline bool SpriterInput::has_options() const {
1115
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1116
 
}
1117
 
inline void SpriterInput::set_has_options() {
1118
 
  _has_bits_[0] |= 0x00000002u;
1119
 
}
1120
 
inline void SpriterInput::clear_has_options() {
1121
 
  _has_bits_[0] &= ~0x00000002u;
1122
 
}
1123
 
inline void SpriterInput::clear_options() {
1124
 
  if (options_ != NULL) options_->::net_instaweb::spriter::SpriteOptions::Clear();
1125
 
  clear_has_options();
1126
 
}
1127
 
inline const ::net_instaweb::spriter::SpriteOptions& SpriterInput::options() const {
1128
 
  return options_ != NULL ? *options_ : *default_instance_->options_;
1129
 
}
1130
 
inline ::net_instaweb::spriter::SpriteOptions* SpriterInput::mutable_options() {
1131
 
  set_has_options();
1132
 
  if (options_ == NULL) options_ = new ::net_instaweb::spriter::SpriteOptions;
1133
 
  return options_;
1134
 
}
1135
 
inline ::net_instaweb::spriter::SpriteOptions* SpriterInput::release_options() {
1136
 
  clear_has_options();
1137
 
  ::net_instaweb::spriter::SpriteOptions* temp = options_;
1138
 
  options_ = NULL;
1139
 
  return temp;
1140
 
}
1141
 
inline void SpriterInput::set_allocated_options(::net_instaweb::spriter::SpriteOptions* options) {
1142
 
  delete options_;
1143
 
  options_ = options;
1144
 
  if (options) {
1145
 
    set_has_options();
1146
 
  } else {
1147
 
    clear_has_options();
1148
 
  }
1149
 
}
1150
 
 
1151
 
// repeated .net_instaweb.spriter.Image input_image_set = 3;
1152
 
inline int SpriterInput::input_image_set_size() const {
1153
 
  return input_image_set_.size();
1154
 
}
1155
 
inline void SpriterInput::clear_input_image_set() {
1156
 
  input_image_set_.Clear();
1157
 
}
1158
 
inline const ::net_instaweb::spriter::Image& SpriterInput::input_image_set(int index) const {
1159
 
  return input_image_set_.Get(index);
1160
 
}
1161
 
inline ::net_instaweb::spriter::Image* SpriterInput::mutable_input_image_set(int index) {
1162
 
  return input_image_set_.Mutable(index);
1163
 
}
1164
 
inline ::net_instaweb::spriter::Image* SpriterInput::add_input_image_set() {
1165
 
  return input_image_set_.Add();
1166
 
}
1167
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::Image >&
1168
 
SpriterInput::input_image_set() const {
1169
 
  return input_image_set_;
1170
 
}
1171
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::Image >*
1172
 
SpriterInput::mutable_input_image_set() {
1173
 
  return &input_image_set_;
1174
 
}
1175
 
 
1176
 
// -------------------------------------------------------------------
1177
 
 
1178
 
// Rect
1179
 
 
1180
 
// required int32 x_pos = 1;
1181
 
inline bool Rect::has_x_pos() const {
1182
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1183
 
}
1184
 
inline void Rect::set_has_x_pos() {
1185
 
  _has_bits_[0] |= 0x00000001u;
1186
 
}
1187
 
inline void Rect::clear_has_x_pos() {
1188
 
  _has_bits_[0] &= ~0x00000001u;
1189
 
}
1190
 
inline void Rect::clear_x_pos() {
1191
 
  x_pos_ = 0;
1192
 
  clear_has_x_pos();
1193
 
}
1194
 
inline ::google::protobuf::int32 Rect::x_pos() const {
1195
 
  return x_pos_;
1196
 
}
1197
 
inline void Rect::set_x_pos(::google::protobuf::int32 value) {
1198
 
  set_has_x_pos();
1199
 
  x_pos_ = value;
1200
 
}
1201
 
 
1202
 
// required int32 y_pos = 2;
1203
 
inline bool Rect::has_y_pos() const {
1204
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1205
 
}
1206
 
inline void Rect::set_has_y_pos() {
1207
 
  _has_bits_[0] |= 0x00000002u;
1208
 
}
1209
 
inline void Rect::clear_has_y_pos() {
1210
 
  _has_bits_[0] &= ~0x00000002u;
1211
 
}
1212
 
inline void Rect::clear_y_pos() {
1213
 
  y_pos_ = 0;
1214
 
  clear_has_y_pos();
1215
 
}
1216
 
inline ::google::protobuf::int32 Rect::y_pos() const {
1217
 
  return y_pos_;
1218
 
}
1219
 
inline void Rect::set_y_pos(::google::protobuf::int32 value) {
1220
 
  set_has_y_pos();
1221
 
  y_pos_ = value;
1222
 
}
1223
 
 
1224
 
// required int32 width = 3;
1225
 
inline bool Rect::has_width() const {
1226
 
  return (_has_bits_[0] & 0x00000004u) != 0;
1227
 
}
1228
 
inline void Rect::set_has_width() {
1229
 
  _has_bits_[0] |= 0x00000004u;
1230
 
}
1231
 
inline void Rect::clear_has_width() {
1232
 
  _has_bits_[0] &= ~0x00000004u;
1233
 
}
1234
 
inline void Rect::clear_width() {
1235
 
  width_ = 0;
1236
 
  clear_has_width();
1237
 
}
1238
 
inline ::google::protobuf::int32 Rect::width() const {
1239
 
  return width_;
1240
 
}
1241
 
inline void Rect::set_width(::google::protobuf::int32 value) {
1242
 
  set_has_width();
1243
 
  width_ = value;
1244
 
}
1245
 
 
1246
 
// required int32 height = 4;
1247
 
inline bool Rect::has_height() const {
1248
 
  return (_has_bits_[0] & 0x00000008u) != 0;
1249
 
}
1250
 
inline void Rect::set_has_height() {
1251
 
  _has_bits_[0] |= 0x00000008u;
1252
 
}
1253
 
inline void Rect::clear_has_height() {
1254
 
  _has_bits_[0] &= ~0x00000008u;
1255
 
}
1256
 
inline void Rect::clear_height() {
1257
 
  height_ = 0;
1258
 
  clear_has_height();
1259
 
}
1260
 
inline ::google::protobuf::int32 Rect::height() const {
1261
 
  return height_;
1262
 
}
1263
 
inline void Rect::set_height(::google::protobuf::int32 value) {
1264
 
  set_has_height();
1265
 
  height_ = value;
1266
 
}
1267
 
 
1268
 
// -------------------------------------------------------------------
1269
 
 
1270
 
// ImagePosition
1271
 
 
1272
 
// required string path = 1;
1273
 
inline bool ImagePosition::has_path() const {
1274
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1275
 
}
1276
 
inline void ImagePosition::set_has_path() {
1277
 
  _has_bits_[0] |= 0x00000001u;
1278
 
}
1279
 
inline void ImagePosition::clear_has_path() {
1280
 
  _has_bits_[0] &= ~0x00000001u;
1281
 
}
1282
 
inline void ImagePosition::clear_path() {
1283
 
  if (path_ != &::google::protobuf::internal::GetEmptyString()) {
1284
 
    path_->clear();
1285
 
  }
1286
 
  clear_has_path();
1287
 
}
1288
 
inline const ::std::string& ImagePosition::path() const {
1289
 
  return *path_;
1290
 
}
1291
 
inline void ImagePosition::set_path(const ::std::string& value) {
1292
 
  set_has_path();
1293
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
1294
 
    path_ = new ::std::string;
1295
 
  }
1296
 
  path_->assign(value);
1297
 
}
1298
 
inline void ImagePosition::set_path(const char* value) {
1299
 
  set_has_path();
1300
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
1301
 
    path_ = new ::std::string;
1302
 
  }
1303
 
  path_->assign(value);
1304
 
}
1305
 
inline void ImagePosition::set_path(const char* value, size_t size) {
1306
 
  set_has_path();
1307
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
1308
 
    path_ = new ::std::string;
1309
 
  }
1310
 
  path_->assign(reinterpret_cast<const char*>(value), size);
1311
 
}
1312
 
inline ::std::string* ImagePosition::mutable_path() {
1313
 
  set_has_path();
1314
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
1315
 
    path_ = new ::std::string;
1316
 
  }
1317
 
  return path_;
1318
 
}
1319
 
inline ::std::string* ImagePosition::release_path() {
1320
 
  clear_has_path();
1321
 
  if (path_ == &::google::protobuf::internal::GetEmptyString()) {
1322
 
    return NULL;
1323
 
  } else {
1324
 
    ::std::string* temp = path_;
1325
 
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1326
 
    return temp;
1327
 
  }
1328
 
}
1329
 
inline void ImagePosition::set_allocated_path(::std::string* path) {
1330
 
  if (path_ != &::google::protobuf::internal::GetEmptyString()) {
1331
 
    delete path_;
1332
 
  }
1333
 
  if (path) {
1334
 
    set_has_path();
1335
 
    path_ = path;
1336
 
  } else {
1337
 
    clear_has_path();
1338
 
    path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1339
 
  }
1340
 
}
1341
 
 
1342
 
// required .net_instaweb.spriter.Rect clip_rect = 2;
1343
 
inline bool ImagePosition::has_clip_rect() const {
1344
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1345
 
}
1346
 
inline void ImagePosition::set_has_clip_rect() {
1347
 
  _has_bits_[0] |= 0x00000002u;
1348
 
}
1349
 
inline void ImagePosition::clear_has_clip_rect() {
1350
 
  _has_bits_[0] &= ~0x00000002u;
1351
 
}
1352
 
inline void ImagePosition::clear_clip_rect() {
1353
 
  if (clip_rect_ != NULL) clip_rect_->::net_instaweb::spriter::Rect::Clear();
1354
 
  clear_has_clip_rect();
1355
 
}
1356
 
inline const ::net_instaweb::spriter::Rect& ImagePosition::clip_rect() const {
1357
 
  return clip_rect_ != NULL ? *clip_rect_ : *default_instance_->clip_rect_;
1358
 
}
1359
 
inline ::net_instaweb::spriter::Rect* ImagePosition::mutable_clip_rect() {
1360
 
  set_has_clip_rect();
1361
 
  if (clip_rect_ == NULL) clip_rect_ = new ::net_instaweb::spriter::Rect;
1362
 
  return clip_rect_;
1363
 
}
1364
 
inline ::net_instaweb::spriter::Rect* ImagePosition::release_clip_rect() {
1365
 
  clear_has_clip_rect();
1366
 
  ::net_instaweb::spriter::Rect* temp = clip_rect_;
1367
 
  clip_rect_ = NULL;
1368
 
  return temp;
1369
 
}
1370
 
inline void ImagePosition::set_allocated_clip_rect(::net_instaweb::spriter::Rect* clip_rect) {
1371
 
  delete clip_rect_;
1372
 
  clip_rect_ = clip_rect;
1373
 
  if (clip_rect) {
1374
 
    set_has_clip_rect();
1375
 
  } else {
1376
 
    clear_has_clip_rect();
1377
 
  }
1378
 
}
1379
 
 
1380
 
// -------------------------------------------------------------------
1381
 
 
1382
 
// SpriterResult
1383
 
 
1384
 
// required int32 id = 1;
1385
 
inline bool SpriterResult::has_id() const {
1386
 
  return (_has_bits_[0] & 0x00000001u) != 0;
1387
 
}
1388
 
inline void SpriterResult::set_has_id() {
1389
 
  _has_bits_[0] |= 0x00000001u;
1390
 
}
1391
 
inline void SpriterResult::clear_has_id() {
1392
 
  _has_bits_[0] &= ~0x00000001u;
1393
 
}
1394
 
inline void SpriterResult::clear_id() {
1395
 
  id_ = 0;
1396
 
  clear_has_id();
1397
 
}
1398
 
inline ::google::protobuf::int32 SpriterResult::id() const {
1399
 
  return id_;
1400
 
}
1401
 
inline void SpriterResult::set_id(::google::protobuf::int32 value) {
1402
 
  set_has_id();
1403
 
  id_ = value;
1404
 
}
1405
 
 
1406
 
// required string output_base_path = 2;
1407
 
inline bool SpriterResult::has_output_base_path() const {
1408
 
  return (_has_bits_[0] & 0x00000002u) != 0;
1409
 
}
1410
 
inline void SpriterResult::set_has_output_base_path() {
1411
 
  _has_bits_[0] |= 0x00000002u;
1412
 
}
1413
 
inline void SpriterResult::clear_has_output_base_path() {
1414
 
  _has_bits_[0] &= ~0x00000002u;
1415
 
}
1416
 
inline void SpriterResult::clear_output_base_path() {
1417
 
  if (output_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
1418
 
    output_base_path_->clear();
1419
 
  }
1420
 
  clear_has_output_base_path();
1421
 
}
1422
 
inline const ::std::string& SpriterResult::output_base_path() const {
1423
 
  return *output_base_path_;
1424
 
}
1425
 
inline void SpriterResult::set_output_base_path(const ::std::string& value) {
1426
 
  set_has_output_base_path();
1427
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
1428
 
    output_base_path_ = new ::std::string;
1429
 
  }
1430
 
  output_base_path_->assign(value);
1431
 
}
1432
 
inline void SpriterResult::set_output_base_path(const char* value) {
1433
 
  set_has_output_base_path();
1434
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
1435
 
    output_base_path_ = new ::std::string;
1436
 
  }
1437
 
  output_base_path_->assign(value);
1438
 
}
1439
 
inline void SpriterResult::set_output_base_path(const char* value, size_t size) {
1440
 
  set_has_output_base_path();
1441
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
1442
 
    output_base_path_ = new ::std::string;
1443
 
  }
1444
 
  output_base_path_->assign(reinterpret_cast<const char*>(value), size);
1445
 
}
1446
 
inline ::std::string* SpriterResult::mutable_output_base_path() {
1447
 
  set_has_output_base_path();
1448
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
1449
 
    output_base_path_ = new ::std::string;
1450
 
  }
1451
 
  return output_base_path_;
1452
 
}
1453
 
inline ::std::string* SpriterResult::release_output_base_path() {
1454
 
  clear_has_output_base_path();
1455
 
  if (output_base_path_ == &::google::protobuf::internal::GetEmptyString()) {
1456
 
    return NULL;
1457
 
  } else {
1458
 
    ::std::string* temp = output_base_path_;
1459
 
    output_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1460
 
    return temp;
1461
 
  }
1462
 
}
1463
 
inline void SpriterResult::set_allocated_output_base_path(::std::string* output_base_path) {
1464
 
  if (output_base_path_ != &::google::protobuf::internal::GetEmptyString()) {
1465
 
    delete output_base_path_;
1466
 
  }
1467
 
  if (output_base_path) {
1468
 
    set_has_output_base_path();
1469
 
    output_base_path_ = output_base_path;
1470
 
  } else {
1471
 
    clear_has_output_base_path();
1472
 
    output_base_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1473
 
  }
1474
 
}
1475
 
 
1476
 
// required string output_image_path = 3;
1477
 
inline bool SpriterResult::has_output_image_path() const {
1478
 
  return (_has_bits_[0] & 0x00000004u) != 0;
1479
 
}
1480
 
inline void SpriterResult::set_has_output_image_path() {
1481
 
  _has_bits_[0] |= 0x00000004u;
1482
 
}
1483
 
inline void SpriterResult::clear_has_output_image_path() {
1484
 
  _has_bits_[0] &= ~0x00000004u;
1485
 
}
1486
 
inline void SpriterResult::clear_output_image_path() {
1487
 
  if (output_image_path_ != &::google::protobuf::internal::GetEmptyString()) {
1488
 
    output_image_path_->clear();
1489
 
  }
1490
 
  clear_has_output_image_path();
1491
 
}
1492
 
inline const ::std::string& SpriterResult::output_image_path() const {
1493
 
  return *output_image_path_;
1494
 
}
1495
 
inline void SpriterResult::set_output_image_path(const ::std::string& value) {
1496
 
  set_has_output_image_path();
1497
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1498
 
    output_image_path_ = new ::std::string;
1499
 
  }
1500
 
  output_image_path_->assign(value);
1501
 
}
1502
 
inline void SpriterResult::set_output_image_path(const char* value) {
1503
 
  set_has_output_image_path();
1504
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1505
 
    output_image_path_ = new ::std::string;
1506
 
  }
1507
 
  output_image_path_->assign(value);
1508
 
}
1509
 
inline void SpriterResult::set_output_image_path(const char* value, size_t size) {
1510
 
  set_has_output_image_path();
1511
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1512
 
    output_image_path_ = new ::std::string;
1513
 
  }
1514
 
  output_image_path_->assign(reinterpret_cast<const char*>(value), size);
1515
 
}
1516
 
inline ::std::string* SpriterResult::mutable_output_image_path() {
1517
 
  set_has_output_image_path();
1518
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1519
 
    output_image_path_ = new ::std::string;
1520
 
  }
1521
 
  return output_image_path_;
1522
 
}
1523
 
inline ::std::string* SpriterResult::release_output_image_path() {
1524
 
  clear_has_output_image_path();
1525
 
  if (output_image_path_ == &::google::protobuf::internal::GetEmptyString()) {
1526
 
    return NULL;
1527
 
  } else {
1528
 
    ::std::string* temp = output_image_path_;
1529
 
    output_image_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1530
 
    return temp;
1531
 
  }
1532
 
}
1533
 
inline void SpriterResult::set_allocated_output_image_path(::std::string* output_image_path) {
1534
 
  if (output_image_path_ != &::google::protobuf::internal::GetEmptyString()) {
1535
 
    delete output_image_path_;
1536
 
  }
1537
 
  if (output_image_path) {
1538
 
    set_has_output_image_path();
1539
 
    output_image_path_ = output_image_path;
1540
 
  } else {
1541
 
    clear_has_output_image_path();
1542
 
    output_image_path_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyString());
1543
 
  }
1544
 
}
1545
 
 
1546
 
// repeated .net_instaweb.spriter.ImagePosition image_position = 4;
1547
 
inline int SpriterResult::image_position_size() const {
1548
 
  return image_position_.size();
1549
 
}
1550
 
inline void SpriterResult::clear_image_position() {
1551
 
  image_position_.Clear();
1552
 
}
1553
 
inline const ::net_instaweb::spriter::ImagePosition& SpriterResult::image_position(int index) const {
1554
 
  return image_position_.Get(index);
1555
 
}
1556
 
inline ::net_instaweb::spriter::ImagePosition* SpriterResult::mutable_image_position(int index) {
1557
 
  return image_position_.Mutable(index);
1558
 
}
1559
 
inline ::net_instaweb::spriter::ImagePosition* SpriterResult::add_image_position() {
1560
 
  return image_position_.Add();
1561
 
}
1562
 
inline const ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::ImagePosition >&
1563
 
SpriterResult::image_position() const {
1564
 
  return image_position_;
1565
 
}
1566
 
inline ::google::protobuf::RepeatedPtrField< ::net_instaweb::spriter::ImagePosition >*
1567
 
SpriterResult::mutable_image_position() {
1568
 
  return &image_position_;
1569
 
}
1570
 
 
1571
 
 
1572
 
// @@protoc_insertion_point(namespace_scope)
1573
 
 
1574
 
}  // namespace spriter
1575
 
}  // namespace net_instaweb
1576
 
 
1577
 
#ifndef SWIG
1578
 
namespace google {
1579
 
namespace protobuf {
1580
 
 
1581
 
template <>
1582
 
inline const EnumDescriptor* GetEnumDescriptor< ::net_instaweb::spriter::PlacementMethod>() {
1583
 
  return ::net_instaweb::spriter::PlacementMethod_descriptor();
1584
 
}
1585
 
template <>
1586
 
inline const EnumDescriptor* GetEnumDescriptor< ::net_instaweb::spriter::ImageFormat>() {
1587
 
  return ::net_instaweb::spriter::ImageFormat_descriptor();
1588
 
}
1589
 
 
1590
 
}  // namespace google
1591
 
}  // namespace protobuf
1592
 
#endif  // SWIG
1593
 
 
1594
 
// @@protoc_insertion_point(global_scope)
1595
 
 
1596
 
#endif  // PROTOBUF_net_2finstaweb_2fspriter_2fpublic_2fimage_5fspriter_2eproto__INCLUDED