SVN checkout 11/12/2010
[monav:monav.git] / plugins / osmimporter / protobuff definitions / fileformat.pb.h
1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: fileformat.proto
3
4 #ifndef PROTOBUF_fileformat_2eproto__INCLUDED
5 #define PROTOBUF_fileformat_2eproto__INCLUDED
6
7 #include <string>
8
9 #include <google/protobuf/stubs/common.h>
10
11 #if GOOGLE_PROTOBUF_VERSION < 2003000
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 2003000 < 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/repeated_field.h>
24 #include <google/protobuf/extension_set.h>
25 #include <google/protobuf/generated_message_reflection.h>
26 // @@protoc_insertion_point(includes)
27
28 namespace PBF {
29
30 // Internal implementation detail -- do not call these.
31 void  protobuf_AddDesc_fileformat_2eproto();
32 void protobuf_AssignDesc_fileformat_2eproto();
33 void protobuf_ShutdownFile_fileformat_2eproto();
34
35 class Blob;
36 class BlockHeader;
37
38 // ===================================================================
39
40 class Blob : public ::google::protobuf::Message {
41  public:
42   Blob();
43   virtual ~Blob();
44   
45   Blob(const Blob& from);
46   
47   inline Blob& operator=(const Blob& from) {
48     CopyFrom(from);
49     return *this;
50   }
51   
52   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
53     return _unknown_fields_;
54   }
55   
56   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
57     return &_unknown_fields_;
58   }
59   
60   static const ::google::protobuf::Descriptor* descriptor();
61   static const Blob& default_instance();
62   
63   void Swap(Blob* other);
64   
65   // implements Message ----------------------------------------------
66   
67   Blob* New() const;
68   void CopyFrom(const ::google::protobuf::Message& from);
69   void MergeFrom(const ::google::protobuf::Message& from);
70   void CopyFrom(const Blob& from);
71   void MergeFrom(const Blob& from);
72   void Clear();
73   bool IsInitialized() const;
74   
75   int ByteSize() const;
76   bool MergePartialFromCodedStream(
77       ::google::protobuf::io::CodedInputStream* input);
78   void SerializeWithCachedSizes(
79       ::google::protobuf::io::CodedOutputStream* output) const;
80   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
81   int GetCachedSize() const { return _cached_size_; }
82   private:
83   void SharedCtor();
84   void SharedDtor();
85   void SetCachedSize(int size) const;
86   public:
87   
88   ::google::protobuf::Metadata GetMetadata() const;
89   
90   // nested types ----------------------------------------------------
91   
92   // accessors -------------------------------------------------------
93   
94   // optional bytes raw = 1;
95   inline bool has_raw() const;
96   inline void clear_raw();
97   static const int kRawFieldNumber = 1;
98   inline const ::std::string& raw() const;
99   inline void set_raw(const ::std::string& value);
100   inline void set_raw(const char* value);
101   inline void set_raw(const void* value, size_t size);
102   inline ::std::string* mutable_raw();
103   
104   // optional int32 raw_size = 2;
105   inline bool has_raw_size() const;
106   inline void clear_raw_size();
107   static const int kRawSizeFieldNumber = 2;
108   inline ::google::protobuf::int32 raw_size() const;
109   inline void set_raw_size(::google::protobuf::int32 value);
110   
111   // optional bytes zlib_data = 3;
112   inline bool has_zlib_data() const;
113   inline void clear_zlib_data();
114   static const int kZlibDataFieldNumber = 3;
115   inline const ::std::string& zlib_data() const;
116   inline void set_zlib_data(const ::std::string& value);
117   inline void set_zlib_data(const char* value);
118   inline void set_zlib_data(const void* value, size_t size);
119   inline ::std::string* mutable_zlib_data();
120   
121   // optional bytes lzma_data = 4;
122   inline bool has_lzma_data() const;
123   inline void clear_lzma_data();
124   static const int kLzmaDataFieldNumber = 4;
125   inline const ::std::string& lzma_data() const;
126   inline void set_lzma_data(const ::std::string& value);
127   inline void set_lzma_data(const char* value);
128   inline void set_lzma_data(const void* value, size_t size);
129   inline ::std::string* mutable_lzma_data();
130   
131   // optional bytes bzip2_data = 5;
132   inline bool has_bzip2_data() const;
133   inline void clear_bzip2_data();
134   static const int kBzip2DataFieldNumber = 5;
135   inline const ::std::string& bzip2_data() const;
136   inline void set_bzip2_data(const ::std::string& value);
137   inline void set_bzip2_data(const char* value);
138   inline void set_bzip2_data(const void* value, size_t size);
139   inline ::std::string* mutable_bzip2_data();
140   
141   // @@protoc_insertion_point(class_scope:PBF.Blob)
142  private:
143   ::google::protobuf::UnknownFieldSet _unknown_fields_;
144   mutable int _cached_size_;
145   
146   ::std::string* raw_;
147   static const ::std::string _default_raw_;
148   ::google::protobuf::int32 raw_size_;
149   ::std::string* zlib_data_;
150   static const ::std::string _default_zlib_data_;
151   ::std::string* lzma_data_;
152   static const ::std::string _default_lzma_data_;
153   ::std::string* bzip2_data_;
154   static const ::std::string _default_bzip2_data_;
155   friend void  protobuf_AddDesc_fileformat_2eproto();
156   friend void protobuf_AssignDesc_fileformat_2eproto();
157   friend void protobuf_ShutdownFile_fileformat_2eproto();
158   
159   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
160   
161   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
162   inline bool _has_bit(int index) const {
163     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
164   }
165   inline void _set_bit(int index) {
166     _has_bits_[index / 32] |= (1u << (index % 32));
167   }
168   inline void _clear_bit(int index) {
169     _has_bits_[index / 32] &= ~(1u << (index % 32));
170   }
171   
172   void InitAsDefaultInstance();
173   static Blob* default_instance_;
174 };
175 // -------------------------------------------------------------------
176
177 class BlockHeader : public ::google::protobuf::Message {
178  public:
179   BlockHeader();
180   virtual ~BlockHeader();
181   
182   BlockHeader(const BlockHeader& from);
183   
184   inline BlockHeader& operator=(const BlockHeader& from) {
185     CopyFrom(from);
186     return *this;
187   }
188   
189   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
190     return _unknown_fields_;
191   }
192   
193   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
194     return &_unknown_fields_;
195   }
196   
197   static const ::google::protobuf::Descriptor* descriptor();
198   static const BlockHeader& default_instance();
199   
200   void Swap(BlockHeader* other);
201   
202   // implements Message ----------------------------------------------
203   
204   BlockHeader* New() const;
205   void CopyFrom(const ::google::protobuf::Message& from);
206   void MergeFrom(const ::google::protobuf::Message& from);
207   void CopyFrom(const BlockHeader& from);
208   void MergeFrom(const BlockHeader& from);
209   void Clear();
210   bool IsInitialized() const;
211   
212   int ByteSize() const;
213   bool MergePartialFromCodedStream(
214       ::google::protobuf::io::CodedInputStream* input);
215   void SerializeWithCachedSizes(
216       ::google::protobuf::io::CodedOutputStream* output) const;
217   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
218   int GetCachedSize() const { return _cached_size_; }
219   private:
220   void SharedCtor();
221   void SharedDtor();
222   void SetCachedSize(int size) const;
223   public:
224   
225   ::google::protobuf::Metadata GetMetadata() const;
226   
227   // nested types ----------------------------------------------------
228   
229   // accessors -------------------------------------------------------
230   
231   // required string type = 1;
232   inline bool has_type() const;
233   inline void clear_type();
234   static const int kTypeFieldNumber = 1;
235   inline const ::std::string& type() const;
236   inline void set_type(const ::std::string& value);
237   inline void set_type(const char* value);
238   inline void set_type(const char* value, size_t size);
239   inline ::std::string* mutable_type();
240   
241   // optional bytes indexdata = 2;
242   inline bool has_indexdata() const;
243   inline void clear_indexdata();
244   static const int kIndexdataFieldNumber = 2;
245   inline const ::std::string& indexdata() const;
246   inline void set_indexdata(const ::std::string& value);
247   inline void set_indexdata(const char* value);
248   inline void set_indexdata(const void* value, size_t size);
249   inline ::std::string* mutable_indexdata();
250   
251   // required int32 datasize = 3;
252   inline bool has_datasize() const;
253   inline void clear_datasize();
254   static const int kDatasizeFieldNumber = 3;
255   inline ::google::protobuf::int32 datasize() const;
256   inline void set_datasize(::google::protobuf::int32 value);
257   
258   // @@protoc_insertion_point(class_scope:PBF.BlockHeader)
259  private:
260   ::google::protobuf::UnknownFieldSet _unknown_fields_;
261   mutable int _cached_size_;
262   
263   ::std::string* type_;
264   static const ::std::string _default_type_;
265   ::std::string* indexdata_;
266   static const ::std::string _default_indexdata_;
267   ::google::protobuf::int32 datasize_;
268   friend void  protobuf_AddDesc_fileformat_2eproto();
269   friend void protobuf_AssignDesc_fileformat_2eproto();
270   friend void protobuf_ShutdownFile_fileformat_2eproto();
271   
272   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
273   
274   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
275   inline bool _has_bit(int index) const {
276     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
277   }
278   inline void _set_bit(int index) {
279     _has_bits_[index / 32] |= (1u << (index % 32));
280   }
281   inline void _clear_bit(int index) {
282     _has_bits_[index / 32] &= ~(1u << (index % 32));
283   }
284   
285   void InitAsDefaultInstance();
286   static BlockHeader* default_instance_;
287 };
288 // ===================================================================
289
290
291 // ===================================================================
292
293 // Blob
294
295 // optional bytes raw = 1;
296 inline bool Blob::has_raw() const {
297   return _has_bit(0);
298 }
299 inline void Blob::clear_raw() {
300   if (raw_ != &_default_raw_) {
301     raw_->clear();
302   }
303   _clear_bit(0);
304 }
305 inline const ::std::string& Blob::raw() const {
306   return *raw_;
307 }
308 inline void Blob::set_raw(const ::std::string& value) {
309   _set_bit(0);
310   if (raw_ == &_default_raw_) {
311     raw_ = new ::std::string;
312   }
313   raw_->assign(value);
314 }
315 inline void Blob::set_raw(const char* value) {
316   _set_bit(0);
317   if (raw_ == &_default_raw_) {
318     raw_ = new ::std::string;
319   }
320   raw_->assign(value);
321 }
322 inline void Blob::set_raw(const void* value, size_t size) {
323   _set_bit(0);
324   if (raw_ == &_default_raw_) {
325     raw_ = new ::std::string;
326   }
327   raw_->assign(reinterpret_cast<const char*>(value), size);
328 }
329 inline ::std::string* Blob::mutable_raw() {
330   _set_bit(0);
331   if (raw_ == &_default_raw_) {
332     raw_ = new ::std::string;
333   }
334   return raw_;
335 }
336
337 // optional int32 raw_size = 2;
338 inline bool Blob::has_raw_size() const {
339   return _has_bit(1);
340 }
341 inline void Blob::clear_raw_size() {
342   raw_size_ = 0;
343   _clear_bit(1);
344 }
345 inline ::google::protobuf::int32 Blob::raw_size() const {
346   return raw_size_;
347 }
348 inline void Blob::set_raw_size(::google::protobuf::int32 value) {
349   _set_bit(1);
350   raw_size_ = value;
351 }
352
353 // optional bytes zlib_data = 3;
354 inline bool Blob::has_zlib_data() const {
355   return _has_bit(2);
356 }
357 inline void Blob::clear_zlib_data() {
358   if (zlib_data_ != &_default_zlib_data_) {
359     zlib_data_->clear();
360   }
361   _clear_bit(2);
362 }
363 inline const ::std::string& Blob::zlib_data() const {
364   return *zlib_data_;
365 }
366 inline void Blob::set_zlib_data(const ::std::string& value) {
367   _set_bit(2);
368   if (zlib_data_ == &_default_zlib_data_) {
369     zlib_data_ = new ::std::string;
370   }
371   zlib_data_->assign(value);
372 }
373 inline void Blob::set_zlib_data(const char* value) {
374   _set_bit(2);
375   if (zlib_data_ == &_default_zlib_data_) {
376     zlib_data_ = new ::std::string;
377   }
378   zlib_data_->assign(value);
379 }
380 inline void Blob::set_zlib_data(const void* value, size_t size) {
381   _set_bit(2);
382   if (zlib_data_ == &_default_zlib_data_) {
383     zlib_data_ = new ::std::string;
384   }
385   zlib_data_->assign(reinterpret_cast<const char*>(value), size);
386 }
387 inline ::std::string* Blob::mutable_zlib_data() {
388   _set_bit(2);
389   if (zlib_data_ == &_default_zlib_data_) {
390     zlib_data_ = new ::std::string;
391   }
392   return zlib_data_;
393 }
394
395 // optional bytes lzma_data = 4;
396 inline bool Blob::has_lzma_data() const {
397   return _has_bit(3);
398 }
399 inline void Blob::clear_lzma_data() {
400   if (lzma_data_ != &_default_lzma_data_) {
401     lzma_data_->clear();
402   }
403   _clear_bit(3);
404 }
405 inline const ::std::string& Blob::lzma_data() const {
406   return *lzma_data_;
407 }
408 inline void Blob::set_lzma_data(const ::std::string& value) {
409   _set_bit(3);
410   if (lzma_data_ == &_default_lzma_data_) {
411     lzma_data_ = new ::std::string;
412   }
413   lzma_data_->assign(value);
414 }
415 inline void Blob::set_lzma_data(const char* value) {
416   _set_bit(3);
417   if (lzma_data_ == &_default_lzma_data_) {
418     lzma_data_ = new ::std::string;
419   }
420   lzma_data_->assign(value);
421 }
422 inline void Blob::set_lzma_data(const void* value, size_t size) {
423   _set_bit(3);
424   if (lzma_data_ == &_default_lzma_data_) {
425     lzma_data_ = new ::std::string;
426   }
427   lzma_data_->assign(reinterpret_cast<const char*>(value), size);
428 }
429 inline ::std::string* Blob::mutable_lzma_data() {
430   _set_bit(3);
431   if (lzma_data_ == &_default_lzma_data_) {
432     lzma_data_ = new ::std::string;
433   }
434   return lzma_data_;
435 }
436
437 // optional bytes bzip2_data = 5;
438 inline bool Blob::has_bzip2_data() const {
439   return _has_bit(4);
440 }
441 inline void Blob::clear_bzip2_data() {
442   if (bzip2_data_ != &_default_bzip2_data_) {
443     bzip2_data_->clear();
444   }
445   _clear_bit(4);
446 }
447 inline const ::std::string& Blob::bzip2_data() const {
448   return *bzip2_data_;
449 }
450 inline void Blob::set_bzip2_data(const ::std::string& value) {
451   _set_bit(4);
452   if (bzip2_data_ == &_default_bzip2_data_) {
453     bzip2_data_ = new ::std::string;
454   }
455   bzip2_data_->assign(value);
456 }
457 inline void Blob::set_bzip2_data(const char* value) {
458   _set_bit(4);
459   if (bzip2_data_ == &_default_bzip2_data_) {
460     bzip2_data_ = new ::std::string;
461   }
462   bzip2_data_->assign(value);
463 }
464 inline void Blob::set_bzip2_data(const void* value, size_t size) {
465   _set_bit(4);
466   if (bzip2_data_ == &_default_bzip2_data_) {
467     bzip2_data_ = new ::std::string;
468   }
469   bzip2_data_->assign(reinterpret_cast<const char*>(value), size);
470 }
471 inline ::std::string* Blob::mutable_bzip2_data() {
472   _set_bit(4);
473   if (bzip2_data_ == &_default_bzip2_data_) {
474     bzip2_data_ = new ::std::string;
475   }
476   return bzip2_data_;
477 }
478
479 // -------------------------------------------------------------------
480
481 // BlockHeader
482
483 // required string type = 1;
484 inline bool BlockHeader::has_type() const {
485   return _has_bit(0);
486 }
487 inline void BlockHeader::clear_type() {
488   if (type_ != &_default_type_) {
489     type_->clear();
490   }
491   _clear_bit(0);
492 }
493 inline const ::std::string& BlockHeader::type() const {
494   return *type_;
495 }
496 inline void BlockHeader::set_type(const ::std::string& value) {
497   _set_bit(0);
498   if (type_ == &_default_type_) {
499     type_ = new ::std::string;
500   }
501   type_->assign(value);
502 }
503 inline void BlockHeader::set_type(const char* value) {
504   _set_bit(0);
505   if (type_ == &_default_type_) {
506     type_ = new ::std::string;
507   }
508   type_->assign(value);
509 }
510 inline void BlockHeader::set_type(const char* value, size_t size) {
511   _set_bit(0);
512   if (type_ == &_default_type_) {
513     type_ = new ::std::string;
514   }
515   type_->assign(reinterpret_cast<const char*>(value), size);
516 }
517 inline ::std::string* BlockHeader::mutable_type() {
518   _set_bit(0);
519   if (type_ == &_default_type_) {
520     type_ = new ::std::string;
521   }
522   return type_;
523 }
524
525 // optional bytes indexdata = 2;
526 inline bool BlockHeader::has_indexdata() const {
527   return _has_bit(1);
528 }
529 inline void BlockHeader::clear_indexdata() {
530   if (indexdata_ != &_default_indexdata_) {
531     indexdata_->clear();
532   }
533   _clear_bit(1);
534 }
535 inline const ::std::string& BlockHeader::indexdata() const {
536   return *indexdata_;
537 }
538 inline void BlockHeader::set_indexdata(const ::std::string& value) {
539   _set_bit(1);
540   if (indexdata_ == &_default_indexdata_) {
541     indexdata_ = new ::std::string;
542   }
543   indexdata_->assign(value);
544 }
545 inline void BlockHeader::set_indexdata(const char* value) {
546   _set_bit(1);
547   if (indexdata_ == &_default_indexdata_) {
548     indexdata_ = new ::std::string;
549   }
550   indexdata_->assign(value);
551 }
552 inline void BlockHeader::set_indexdata(const void* value, size_t size) {
553   _set_bit(1);
554   if (indexdata_ == &_default_indexdata_) {
555     indexdata_ = new ::std::string;
556   }
557   indexdata_->assign(reinterpret_cast<const char*>(value), size);
558 }
559 inline ::std::string* BlockHeader::mutable_indexdata() {
560   _set_bit(1);
561   if (indexdata_ == &_default_indexdata_) {
562     indexdata_ = new ::std::string;
563   }
564   return indexdata_;
565 }
566
567 // required int32 datasize = 3;
568 inline bool BlockHeader::has_datasize() const {
569   return _has_bit(2);
570 }
571 inline void BlockHeader::clear_datasize() {
572   datasize_ = 0;
573   _clear_bit(2);
574 }
575 inline ::google::protobuf::int32 BlockHeader::datasize() const {
576   return datasize_;
577 }
578 inline void BlockHeader::set_datasize(::google::protobuf::int32 value) {
579   _set_bit(2);
580   datasize_ = value;
581 }
582
583
584 // @@protoc_insertion_point(namespace_scope)
585
586 }  // namespace PBF
587
588 #ifndef SWIG
589 namespace google {
590 namespace protobuf {
591
592
593 }  // namespace google
594 }  // namespace protobuf
595 #endif  // SWIG
596
597 // @@protoc_insertion_point(global_scope)
598
599 #endif  // PROTOBUF_fileformat_2eproto__INCLUDED