SVN checkout 11/12/2010
[monav:monav.git] / plugins / osmimporter / protobuff definitions / fileformat.pb.cc
1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2
3 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
4 #include "fileformat.pb.h"
5 #include <google/protobuf/stubs/once.h>
6 #include <google/protobuf/io/coded_stream.h>
7 #include <google/protobuf/wire_format_lite_inl.h>
8 #include <google/protobuf/descriptor.h>
9 #include <google/protobuf/reflection_ops.h>
10 #include <google/protobuf/wire_format.h>
11 // @@protoc_insertion_point(includes)
12
13 namespace PBF {
14
15 namespace {
16
17 const ::google::protobuf::Descriptor* Blob_descriptor_ = NULL;
18 const ::google::protobuf::internal::GeneratedMessageReflection*
19   Blob_reflection_ = NULL;
20 const ::google::protobuf::Descriptor* BlockHeader_descriptor_ = NULL;
21 const ::google::protobuf::internal::GeneratedMessageReflection*
22   BlockHeader_reflection_ = NULL;
23
24 }  // namespace
25
26
27 void protobuf_AssignDesc_fileformat_2eproto() {
28   protobuf_AddDesc_fileformat_2eproto();
29   const ::google::protobuf::FileDescriptor* file =
30     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
31       "fileformat.proto");
32   GOOGLE_CHECK(file != NULL);
33   Blob_descriptor_ = file->message_type(0);
34   static const int Blob_offsets_[5] = {
35     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, raw_),
36     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, raw_size_),
37     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, zlib_data_),
38     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, lzma_data_),
39     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, bzip2_data_),
40   };
41   Blob_reflection_ =
42     new ::google::protobuf::internal::GeneratedMessageReflection(
43       Blob_descriptor_,
44       Blob::default_instance_,
45       Blob_offsets_,
46       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, _has_bits_[0]),
47       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Blob, _unknown_fields_),
48       -1,
49       ::google::protobuf::DescriptorPool::generated_pool(),
50       ::google::protobuf::MessageFactory::generated_factory(),
51       sizeof(Blob));
52   BlockHeader_descriptor_ = file->message_type(1);
53   static const int BlockHeader_offsets_[3] = {
54     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockHeader, type_),
55     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockHeader, indexdata_),
56     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockHeader, datasize_),
57   };
58   BlockHeader_reflection_ =
59     new ::google::protobuf::internal::GeneratedMessageReflection(
60       BlockHeader_descriptor_,
61       BlockHeader::default_instance_,
62       BlockHeader_offsets_,
63       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockHeader, _has_bits_[0]),
64       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockHeader, _unknown_fields_),
65       -1,
66       ::google::protobuf::DescriptorPool::generated_pool(),
67       ::google::protobuf::MessageFactory::generated_factory(),
68       sizeof(BlockHeader));
69 }
70
71 namespace {
72
73 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
74 inline void protobuf_AssignDescriptorsOnce() {
75   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
76                  &protobuf_AssignDesc_fileformat_2eproto);
77 }
78
79 void protobuf_RegisterTypes(const ::std::string&) {
80   protobuf_AssignDescriptorsOnce();
81   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
82     Blob_descriptor_, &Blob::default_instance());
83   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
84     BlockHeader_descriptor_, &BlockHeader::default_instance());
85 }
86
87 }  // namespace
88
89 void protobuf_ShutdownFile_fileformat_2eproto() {
90   delete Blob::default_instance_;
91   delete Blob_reflection_;
92   delete BlockHeader::default_instance_;
93   delete BlockHeader_reflection_;
94 }
95
96 void protobuf_AddDesc_fileformat_2eproto() {
97   static bool already_here = false;
98   if (already_here) return;
99   already_here = true;
100   GOOGLE_PROTOBUF_VERIFY_VERSION;
101
102   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
103     "\n\020fileformat.proto\022\003PBF\"_\n\004Blob\022\013\n\003raw\030\001"
104     " \001(\014\022\020\n\010raw_size\030\002 \001(\005\022\021\n\tzlib_data\030\003 \001("
105     "\014\022\021\n\tlzma_data\030\004 \001(\014\022\022\n\nbzip2_data\030\005 \001(\014"
106     "\"@\n\013BlockHeader\022\014\n\004type\030\001 \002(\t\022\021\n\tindexda"
107     "ta\030\002 \001(\014\022\020\n\010datasize\030\003 \002(\005", 186);
108   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
109     "fileformat.proto", &protobuf_RegisterTypes);
110   Blob::default_instance_ = new Blob();
111   BlockHeader::default_instance_ = new BlockHeader();
112   Blob::default_instance_->InitAsDefaultInstance();
113   BlockHeader::default_instance_->InitAsDefaultInstance();
114   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_fileformat_2eproto);
115 }
116
117 // Force AddDescriptors() to be called at static initialization time.
118 struct StaticDescriptorInitializer_fileformat_2eproto {
119   StaticDescriptorInitializer_fileformat_2eproto() {
120     protobuf_AddDesc_fileformat_2eproto();
121   }
122 } static_descriptor_initializer_fileformat_2eproto_;
123
124
125 // ===================================================================
126
127 const ::std::string Blob::_default_raw_;
128 const ::std::string Blob::_default_zlib_data_;
129 const ::std::string Blob::_default_lzma_data_;
130 const ::std::string Blob::_default_bzip2_data_;
131 #ifndef _MSC_VER
132 const int Blob::kRawFieldNumber;
133 const int Blob::kRawSizeFieldNumber;
134 const int Blob::kZlibDataFieldNumber;
135 const int Blob::kLzmaDataFieldNumber;
136 const int Blob::kBzip2DataFieldNumber;
137 #endif  // !_MSC_VER
138
139 Blob::Blob()
140   : ::google::protobuf::Message() {
141   SharedCtor();
142 }
143
144 void Blob::InitAsDefaultInstance() {
145 }
146
147 Blob::Blob(const Blob& from)
148   : ::google::protobuf::Message() {
149   SharedCtor();
150   MergeFrom(from);
151 }
152
153 void Blob::SharedCtor() {
154   _cached_size_ = 0;
155   raw_ = const_cast< ::std::string*>(&_default_raw_);
156   raw_size_ = 0;
157   zlib_data_ = const_cast< ::std::string*>(&_default_zlib_data_);
158   lzma_data_ = const_cast< ::std::string*>(&_default_lzma_data_);
159   bzip2_data_ = const_cast< ::std::string*>(&_default_bzip2_data_);
160   ::memset(_has_bits_, 0, sizeof(_has_bits_));
161 }
162
163 Blob::~Blob() {
164   SharedDtor();
165 }
166
167 void Blob::SharedDtor() {
168   if (raw_ != &_default_raw_) {
169     delete raw_;
170   }
171   if (zlib_data_ != &_default_zlib_data_) {
172     delete zlib_data_;
173   }
174   if (lzma_data_ != &_default_lzma_data_) {
175     delete lzma_data_;
176   }
177   if (bzip2_data_ != &_default_bzip2_data_) {
178     delete bzip2_data_;
179   }
180   if (this != default_instance_) {
181   }
182 }
183
184 void Blob::SetCachedSize(int size) const {
185   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
186   _cached_size_ = size;
187   GOOGLE_SAFE_CONCURRENT_WRITES_END();
188 }
189 const ::google::protobuf::Descriptor* Blob::descriptor() {
190   protobuf_AssignDescriptorsOnce();
191   return Blob_descriptor_;
192 }
193
194 const Blob& Blob::default_instance() {
195   if (default_instance_ == NULL) protobuf_AddDesc_fileformat_2eproto();  return *default_instance_;
196 }
197
198 Blob* Blob::default_instance_ = NULL;
199
200 Blob* Blob::New() const {
201   return new Blob;
202 }
203
204 void Blob::Clear() {
205   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
206     if (_has_bit(0)) {
207       if (raw_ != &_default_raw_) {
208         raw_->clear();
209       }
210     }
211     raw_size_ = 0;
212     if (_has_bit(2)) {
213       if (zlib_data_ != &_default_zlib_data_) {
214         zlib_data_->clear();
215       }
216     }
217     if (_has_bit(3)) {
218       if (lzma_data_ != &_default_lzma_data_) {
219         lzma_data_->clear();
220       }
221     }
222     if (_has_bit(4)) {
223       if (bzip2_data_ != &_default_bzip2_data_) {
224         bzip2_data_->clear();
225       }
226     }
227   }
228   ::memset(_has_bits_, 0, sizeof(_has_bits_));
229   mutable_unknown_fields()->Clear();
230 }
231
232 bool Blob::MergePartialFromCodedStream(
233     ::google::protobuf::io::CodedInputStream* input) {
234 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
235   ::google::protobuf::uint32 tag;
236   while ((tag = input->ReadTag()) != 0) {
237     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
238       // optional bytes raw = 1;
239       case 1: {
240         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
241             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
242           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
243                 input, this->mutable_raw()));
244         } else {
245           goto handle_uninterpreted;
246         }
247         if (input->ExpectTag(16)) goto parse_raw_size;
248         break;
249       }
250       
251       // optional int32 raw_size = 2;
252       case 2: {
253         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
254             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
255          parse_raw_size:
256           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
257                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
258                  input, &raw_size_)));
259           _set_bit(1);
260         } else {
261           goto handle_uninterpreted;
262         }
263         if (input->ExpectTag(26)) goto parse_zlib_data;
264         break;
265       }
266       
267       // optional bytes zlib_data = 3;
268       case 3: {
269         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
270             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
271          parse_zlib_data:
272           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
273                 input, this->mutable_zlib_data()));
274         } else {
275           goto handle_uninterpreted;
276         }
277         if (input->ExpectTag(34)) goto parse_lzma_data;
278         break;
279       }
280       
281       // optional bytes lzma_data = 4;
282       case 4: {
283         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
284             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
285          parse_lzma_data:
286           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
287                 input, this->mutable_lzma_data()));
288         } else {
289           goto handle_uninterpreted;
290         }
291         if (input->ExpectTag(42)) goto parse_bzip2_data;
292         break;
293       }
294       
295       // optional bytes bzip2_data = 5;
296       case 5: {
297         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
298             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
299          parse_bzip2_data:
300           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
301                 input, this->mutable_bzip2_data()));
302         } else {
303           goto handle_uninterpreted;
304         }
305         if (input->ExpectAtEnd()) return true;
306         break;
307       }
308       
309       default: {
310       handle_uninterpreted:
311         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
312             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
313           return true;
314         }
315         DO_(::google::protobuf::internal::WireFormat::SkipField(
316               input, tag, mutable_unknown_fields()));
317         break;
318       }
319     }
320   }
321   return true;
322 #undef DO_
323 }
324
325 void Blob::SerializeWithCachedSizes(
326     ::google::protobuf::io::CodedOutputStream* output) const {
327   // optional bytes raw = 1;
328   if (_has_bit(0)) {
329     ::google::protobuf::internal::WireFormatLite::WriteBytes(
330       1, this->raw(), output);
331   }
332   
333   // optional int32 raw_size = 2;
334   if (_has_bit(1)) {
335     ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->raw_size(), output);
336   }
337   
338   // optional bytes zlib_data = 3;
339   if (_has_bit(2)) {
340     ::google::protobuf::internal::WireFormatLite::WriteBytes(
341       3, this->zlib_data(), output);
342   }
343   
344   // optional bytes lzma_data = 4;
345   if (_has_bit(3)) {
346     ::google::protobuf::internal::WireFormatLite::WriteBytes(
347       4, this->lzma_data(), output);
348   }
349   
350   // optional bytes bzip2_data = 5;
351   if (_has_bit(4)) {
352     ::google::protobuf::internal::WireFormatLite::WriteBytes(
353       5, this->bzip2_data(), output);
354   }
355   
356   if (!unknown_fields().empty()) {
357     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
358         unknown_fields(), output);
359   }
360 }
361
362 ::google::protobuf::uint8* Blob::SerializeWithCachedSizesToArray(
363     ::google::protobuf::uint8* target) const {
364   // optional bytes raw = 1;
365   if (_has_bit(0)) {
366     target =
367       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
368         1, this->raw(), target);
369   }
370   
371   // optional int32 raw_size = 2;
372   if (_has_bit(1)) {
373     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->raw_size(), target);
374   }
375   
376   // optional bytes zlib_data = 3;
377   if (_has_bit(2)) {
378     target =
379       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
380         3, this->zlib_data(), target);
381   }
382   
383   // optional bytes lzma_data = 4;
384   if (_has_bit(3)) {
385     target =
386       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
387         4, this->lzma_data(), target);
388   }
389   
390   // optional bytes bzip2_data = 5;
391   if (_has_bit(4)) {
392     target =
393       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
394         5, this->bzip2_data(), target);
395   }
396   
397   if (!unknown_fields().empty()) {
398     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
399         unknown_fields(), target);
400   }
401   return target;
402 }
403
404 int Blob::ByteSize() const {
405   int total_size = 0;
406   
407   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
408     // optional bytes raw = 1;
409     if (has_raw()) {
410       total_size += 1 +
411         ::google::protobuf::internal::WireFormatLite::BytesSize(
412           this->raw());
413     }
414     
415     // optional int32 raw_size = 2;
416     if (has_raw_size()) {
417       total_size += 1 +
418         ::google::protobuf::internal::WireFormatLite::Int32Size(
419           this->raw_size());
420     }
421     
422     // optional bytes zlib_data = 3;
423     if (has_zlib_data()) {
424       total_size += 1 +
425         ::google::protobuf::internal::WireFormatLite::BytesSize(
426           this->zlib_data());
427     }
428     
429     // optional bytes lzma_data = 4;
430     if (has_lzma_data()) {
431       total_size += 1 +
432         ::google::protobuf::internal::WireFormatLite::BytesSize(
433           this->lzma_data());
434     }
435     
436     // optional bytes bzip2_data = 5;
437     if (has_bzip2_data()) {
438       total_size += 1 +
439         ::google::protobuf::internal::WireFormatLite::BytesSize(
440           this->bzip2_data());
441     }
442     
443   }
444   if (!unknown_fields().empty()) {
445     total_size +=
446       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
447         unknown_fields());
448   }
449   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
450   _cached_size_ = total_size;
451   GOOGLE_SAFE_CONCURRENT_WRITES_END();
452   return total_size;
453 }
454
455 void Blob::MergeFrom(const ::google::protobuf::Message& from) {
456   GOOGLE_CHECK_NE(&from, this);
457   const Blob* source =
458     ::google::protobuf::internal::dynamic_cast_if_available<const Blob*>(
459       &from);
460   if (source == NULL) {
461     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
462   } else {
463     MergeFrom(*source);
464   }
465 }
466
467 void Blob::MergeFrom(const Blob& from) {
468   GOOGLE_CHECK_NE(&from, this);
469   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
470     if (from._has_bit(0)) {
471       set_raw(from.raw());
472     }
473     if (from._has_bit(1)) {
474       set_raw_size(from.raw_size());
475     }
476     if (from._has_bit(2)) {
477       set_zlib_data(from.zlib_data());
478     }
479     if (from._has_bit(3)) {
480       set_lzma_data(from.lzma_data());
481     }
482     if (from._has_bit(4)) {
483       set_bzip2_data(from.bzip2_data());
484     }
485   }
486   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
487 }
488
489 void Blob::CopyFrom(const ::google::protobuf::Message& from) {
490   if (&from == this) return;
491   Clear();
492   MergeFrom(from);
493 }
494
495 void Blob::CopyFrom(const Blob& from) {
496   if (&from == this) return;
497   Clear();
498   MergeFrom(from);
499 }
500
501 bool Blob::IsInitialized() const {
502   
503   return true;
504 }
505
506 void Blob::Swap(Blob* other) {
507   if (other != this) {
508     std::swap(raw_, other->raw_);
509     std::swap(raw_size_, other->raw_size_);
510     std::swap(zlib_data_, other->zlib_data_);
511     std::swap(lzma_data_, other->lzma_data_);
512     std::swap(bzip2_data_, other->bzip2_data_);
513     std::swap(_has_bits_[0], other->_has_bits_[0]);
514     _unknown_fields_.Swap(&other->_unknown_fields_);
515     std::swap(_cached_size_, other->_cached_size_);
516   }
517 }
518
519 ::google::protobuf::Metadata Blob::GetMetadata() const {
520   protobuf_AssignDescriptorsOnce();
521   ::google::protobuf::Metadata metadata;
522   metadata.descriptor = Blob_descriptor_;
523   metadata.reflection = Blob_reflection_;
524   return metadata;
525 }
526
527
528 // ===================================================================
529
530 const ::std::string BlockHeader::_default_type_;
531 const ::std::string BlockHeader::_default_indexdata_;
532 #ifndef _MSC_VER
533 const int BlockHeader::kTypeFieldNumber;
534 const int BlockHeader::kIndexdataFieldNumber;
535 const int BlockHeader::kDatasizeFieldNumber;
536 #endif  // !_MSC_VER
537
538 BlockHeader::BlockHeader()
539   : ::google::protobuf::Message() {
540   SharedCtor();
541 }
542
543 void BlockHeader::InitAsDefaultInstance() {
544 }
545
546 BlockHeader::BlockHeader(const BlockHeader& from)
547   : ::google::protobuf::Message() {
548   SharedCtor();
549   MergeFrom(from);
550 }
551
552 void BlockHeader::SharedCtor() {
553   _cached_size_ = 0;
554   type_ = const_cast< ::std::string*>(&_default_type_);
555   indexdata_ = const_cast< ::std::string*>(&_default_indexdata_);
556   datasize_ = 0;
557   ::memset(_has_bits_, 0, sizeof(_has_bits_));
558 }
559
560 BlockHeader::~BlockHeader() {
561   SharedDtor();
562 }
563
564 void BlockHeader::SharedDtor() {
565   if (type_ != &_default_type_) {
566     delete type_;
567   }
568   if (indexdata_ != &_default_indexdata_) {
569     delete indexdata_;
570   }
571   if (this != default_instance_) {
572   }
573 }
574
575 void BlockHeader::SetCachedSize(int size) const {
576   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
577   _cached_size_ = size;
578   GOOGLE_SAFE_CONCURRENT_WRITES_END();
579 }
580 const ::google::protobuf::Descriptor* BlockHeader::descriptor() {
581   protobuf_AssignDescriptorsOnce();
582   return BlockHeader_descriptor_;
583 }
584
585 const BlockHeader& BlockHeader::default_instance() {
586   if (default_instance_ == NULL) protobuf_AddDesc_fileformat_2eproto();  return *default_instance_;
587 }
588
589 BlockHeader* BlockHeader::default_instance_ = NULL;
590
591 BlockHeader* BlockHeader::New() const {
592   return new BlockHeader;
593 }
594
595 void BlockHeader::Clear() {
596   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
597     if (_has_bit(0)) {
598       if (type_ != &_default_type_) {
599         type_->clear();
600       }
601     }
602     if (_has_bit(1)) {
603       if (indexdata_ != &_default_indexdata_) {
604         indexdata_->clear();
605       }
606     }
607     datasize_ = 0;
608   }
609   ::memset(_has_bits_, 0, sizeof(_has_bits_));
610   mutable_unknown_fields()->Clear();
611 }
612
613 bool BlockHeader::MergePartialFromCodedStream(
614     ::google::protobuf::io::CodedInputStream* input) {
615 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
616   ::google::protobuf::uint32 tag;
617   while ((tag = input->ReadTag()) != 0) {
618     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
619       // required string type = 1;
620       case 1: {
621         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
622             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
623           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
624                 input, this->mutable_type()));
625           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
626             this->type().data(), this->type().length(),
627             ::google::protobuf::internal::WireFormat::PARSE);
628         } else {
629           goto handle_uninterpreted;
630         }
631         if (input->ExpectTag(18)) goto parse_indexdata;
632         break;
633       }
634       
635       // optional bytes indexdata = 2;
636       case 2: {
637         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
638             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
639          parse_indexdata:
640           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
641                 input, this->mutable_indexdata()));
642         } else {
643           goto handle_uninterpreted;
644         }
645         if (input->ExpectTag(24)) goto parse_datasize;
646         break;
647       }
648       
649       // required int32 datasize = 3;
650       case 3: {
651         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
652             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
653          parse_datasize:
654           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
655                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
656                  input, &datasize_)));
657           _set_bit(2);
658         } else {
659           goto handle_uninterpreted;
660         }
661         if (input->ExpectAtEnd()) return true;
662         break;
663       }
664       
665       default: {
666       handle_uninterpreted:
667         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
668             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
669           return true;
670         }
671         DO_(::google::protobuf::internal::WireFormat::SkipField(
672               input, tag, mutable_unknown_fields()));
673         break;
674       }
675     }
676   }
677   return true;
678 #undef DO_
679 }
680
681 void BlockHeader::SerializeWithCachedSizes(
682     ::google::protobuf::io::CodedOutputStream* output) const {
683   // required string type = 1;
684   if (_has_bit(0)) {
685     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
686       this->type().data(), this->type().length(),
687       ::google::protobuf::internal::WireFormat::SERIALIZE);
688     ::google::protobuf::internal::WireFormatLite::WriteString(
689       1, this->type(), output);
690   }
691   
692   // optional bytes indexdata = 2;
693   if (_has_bit(1)) {
694     ::google::protobuf::internal::WireFormatLite::WriteBytes(
695       2, this->indexdata(), output);
696   }
697   
698   // required int32 datasize = 3;
699   if (_has_bit(2)) {
700     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->datasize(), output);
701   }
702   
703   if (!unknown_fields().empty()) {
704     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
705         unknown_fields(), output);
706   }
707 }
708
709 ::google::protobuf::uint8* BlockHeader::SerializeWithCachedSizesToArray(
710     ::google::protobuf::uint8* target) const {
711   // required string type = 1;
712   if (_has_bit(0)) {
713     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
714       this->type().data(), this->type().length(),
715       ::google::protobuf::internal::WireFormat::SERIALIZE);
716     target =
717       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
718         1, this->type(), target);
719   }
720   
721   // optional bytes indexdata = 2;
722   if (_has_bit(1)) {
723     target =
724       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
725         2, this->indexdata(), target);
726   }
727   
728   // required int32 datasize = 3;
729   if (_has_bit(2)) {
730     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->datasize(), target);
731   }
732   
733   if (!unknown_fields().empty()) {
734     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
735         unknown_fields(), target);
736   }
737   return target;
738 }
739
740 int BlockHeader::ByteSize() const {
741   int total_size = 0;
742   
743   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
744     // required string type = 1;
745     if (has_type()) {
746       total_size += 1 +
747         ::google::protobuf::internal::WireFormatLite::StringSize(
748           this->type());
749     }
750     
751     // optional bytes indexdata = 2;
752     if (has_indexdata()) {
753       total_size += 1 +
754         ::google::protobuf::internal::WireFormatLite::BytesSize(
755           this->indexdata());
756     }
757     
758     // required int32 datasize = 3;
759     if (has_datasize()) {
760       total_size += 1 +
761         ::google::protobuf::internal::WireFormatLite::Int32Size(
762           this->datasize());
763     }
764     
765   }
766   if (!unknown_fields().empty()) {
767     total_size +=
768       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
769         unknown_fields());
770   }
771   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
772   _cached_size_ = total_size;
773   GOOGLE_SAFE_CONCURRENT_WRITES_END();
774   return total_size;
775 }
776
777 void BlockHeader::MergeFrom(const ::google::protobuf::Message& from) {
778   GOOGLE_CHECK_NE(&from, this);
779   const BlockHeader* source =
780     ::google::protobuf::internal::dynamic_cast_if_available<const BlockHeader*>(
781       &from);
782   if (source == NULL) {
783     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
784   } else {
785     MergeFrom(*source);
786   }
787 }
788
789 void BlockHeader::MergeFrom(const BlockHeader& from) {
790   GOOGLE_CHECK_NE(&from, this);
791   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
792     if (from._has_bit(0)) {
793       set_type(from.type());
794     }
795     if (from._has_bit(1)) {
796       set_indexdata(from.indexdata());
797     }
798     if (from._has_bit(2)) {
799       set_datasize(from.datasize());
800     }
801   }
802   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
803 }
804
805 void BlockHeader::CopyFrom(const ::google::protobuf::Message& from) {
806   if (&from == this) return;
807   Clear();
808   MergeFrom(from);
809 }
810
811 void BlockHeader::CopyFrom(const BlockHeader& from) {
812   if (&from == this) return;
813   Clear();
814   MergeFrom(from);
815 }
816
817 bool BlockHeader::IsInitialized() const {
818   if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
819   
820   return true;
821 }
822
823 void BlockHeader::Swap(BlockHeader* other) {
824   if (other != this) {
825     std::swap(type_, other->type_);
826     std::swap(indexdata_, other->indexdata_);
827     std::swap(datasize_, other->datasize_);
828     std::swap(_has_bits_[0], other->_has_bits_[0]);
829     _unknown_fields_.Swap(&other->_unknown_fields_);
830     std::swap(_cached_size_, other->_cached_size_);
831   }
832 }
833
834 ::google::protobuf::Metadata BlockHeader::GetMetadata() const {
835   protobuf_AssignDescriptorsOnce();
836   ::google::protobuf::Metadata metadata;
837   metadata.descriptor = BlockHeader_descriptor_;
838   metadata.reflection = BlockHeader_reflection_;
839   return metadata;
840 }
841
842
843 // @@protoc_insertion_point(namespace_scope)
844
845 }  // namespace PBF
846
847 // @@protoc_insertion_point(global_scope)