SVN checkout 11/12/2010
[monav:monav.git] / plugins / osmimporter / protobuff definitions / osmformat.pb.cc
1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2
3 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
4 #include "osmformat.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* HeaderBlock_descriptor_ = NULL;
18 const ::google::protobuf::internal::GeneratedMessageReflection*
19   HeaderBlock_reflection_ = NULL;
20 const ::google::protobuf::Descriptor* HeaderBBox_descriptor_ = NULL;
21 const ::google::protobuf::internal::GeneratedMessageReflection*
22   HeaderBBox_reflection_ = NULL;
23 const ::google::protobuf::Descriptor* PrimitiveBlock_descriptor_ = NULL;
24 const ::google::protobuf::internal::GeneratedMessageReflection*
25   PrimitiveBlock_reflection_ = NULL;
26 const ::google::protobuf::Descriptor* PrimitiveGroup_descriptor_ = NULL;
27 const ::google::protobuf::internal::GeneratedMessageReflection*
28   PrimitiveGroup_reflection_ = NULL;
29 const ::google::protobuf::Descriptor* StringTable_descriptor_ = NULL;
30 const ::google::protobuf::internal::GeneratedMessageReflection*
31   StringTable_reflection_ = NULL;
32 const ::google::protobuf::Descriptor* Info_descriptor_ = NULL;
33 const ::google::protobuf::internal::GeneratedMessageReflection*
34   Info_reflection_ = NULL;
35 const ::google::protobuf::Descriptor* DenseInfo_descriptor_ = NULL;
36 const ::google::protobuf::internal::GeneratedMessageReflection*
37   DenseInfo_reflection_ = NULL;
38 const ::google::protobuf::Descriptor* ChangeSet_descriptor_ = NULL;
39 const ::google::protobuf::internal::GeneratedMessageReflection*
40   ChangeSet_reflection_ = NULL;
41 const ::google::protobuf::Descriptor* Node_descriptor_ = NULL;
42 const ::google::protobuf::internal::GeneratedMessageReflection*
43   Node_reflection_ = NULL;
44 const ::google::protobuf::Descriptor* DenseNodes_descriptor_ = NULL;
45 const ::google::protobuf::internal::GeneratedMessageReflection*
46   DenseNodes_reflection_ = NULL;
47 const ::google::protobuf::Descriptor* Way_descriptor_ = NULL;
48 const ::google::protobuf::internal::GeneratedMessageReflection*
49   Way_reflection_ = NULL;
50 const ::google::protobuf::Descriptor* Relation_descriptor_ = NULL;
51 const ::google::protobuf::internal::GeneratedMessageReflection*
52   Relation_reflection_ = NULL;
53 const ::google::protobuf::EnumDescriptor* Relation_MemberType_descriptor_ = NULL;
54
55 }  // namespace
56
57
58 void protobuf_AssignDesc_osmformat_2eproto() {
59   protobuf_AddDesc_osmformat_2eproto();
60   const ::google::protobuf::FileDescriptor* file =
61     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
62       "osmformat.proto");
63   GOOGLE_CHECK(file != NULL);
64   HeaderBlock_descriptor_ = file->message_type(0);
65   static const int HeaderBlock_offsets_[5] = {
66     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, bbox_),
67     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, required_features_),
68     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, optional_features_),
69     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, writingprogram_),
70     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, source_),
71   };
72   HeaderBlock_reflection_ =
73     new ::google::protobuf::internal::GeneratedMessageReflection(
74       HeaderBlock_descriptor_,
75       HeaderBlock::default_instance_,
76       HeaderBlock_offsets_,
77       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, _has_bits_[0]),
78       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBlock, _unknown_fields_),
79       -1,
80       ::google::protobuf::DescriptorPool::generated_pool(),
81       ::google::protobuf::MessageFactory::generated_factory(),
82       sizeof(HeaderBlock));
83   HeaderBBox_descriptor_ = file->message_type(1);
84   static const int HeaderBBox_offsets_[4] = {
85     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, left_),
86     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, right_),
87     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, top_),
88     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, bottom_),
89   };
90   HeaderBBox_reflection_ =
91     new ::google::protobuf::internal::GeneratedMessageReflection(
92       HeaderBBox_descriptor_,
93       HeaderBBox::default_instance_,
94       HeaderBBox_offsets_,
95       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, _has_bits_[0]),
96       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(HeaderBBox, _unknown_fields_),
97       -1,
98       ::google::protobuf::DescriptorPool::generated_pool(),
99       ::google::protobuf::MessageFactory::generated_factory(),
100       sizeof(HeaderBBox));
101   PrimitiveBlock_descriptor_ = file->message_type(2);
102   static const int PrimitiveBlock_offsets_[6] = {
103     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, stringtable_),
104     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, primitivegroup_),
105     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, granularity_),
106     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, lat_offset_),
107     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, lon_offset_),
108     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, date_granularity_),
109   };
110   PrimitiveBlock_reflection_ =
111     new ::google::protobuf::internal::GeneratedMessageReflection(
112       PrimitiveBlock_descriptor_,
113       PrimitiveBlock::default_instance_,
114       PrimitiveBlock_offsets_,
115       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, _has_bits_[0]),
116       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveBlock, _unknown_fields_),
117       -1,
118       ::google::protobuf::DescriptorPool::generated_pool(),
119       ::google::protobuf::MessageFactory::generated_factory(),
120       sizeof(PrimitiveBlock));
121   PrimitiveGroup_descriptor_ = file->message_type(3);
122   static const int PrimitiveGroup_offsets_[5] = {
123     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, nodes_),
124     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, dense_),
125     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, ways_),
126     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, relations_),
127     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, changesets_),
128   };
129   PrimitiveGroup_reflection_ =
130     new ::google::protobuf::internal::GeneratedMessageReflection(
131       PrimitiveGroup_descriptor_,
132       PrimitiveGroup::default_instance_,
133       PrimitiveGroup_offsets_,
134       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, _has_bits_[0]),
135       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrimitiveGroup, _unknown_fields_),
136       -1,
137       ::google::protobuf::DescriptorPool::generated_pool(),
138       ::google::protobuf::MessageFactory::generated_factory(),
139       sizeof(PrimitiveGroup));
140   StringTable_descriptor_ = file->message_type(4);
141   static const int StringTable_offsets_[1] = {
142     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringTable, s_),
143   };
144   StringTable_reflection_ =
145     new ::google::protobuf::internal::GeneratedMessageReflection(
146       StringTable_descriptor_,
147       StringTable::default_instance_,
148       StringTable_offsets_,
149       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringTable, _has_bits_[0]),
150       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringTable, _unknown_fields_),
151       -1,
152       ::google::protobuf::DescriptorPool::generated_pool(),
153       ::google::protobuf::MessageFactory::generated_factory(),
154       sizeof(StringTable));
155   Info_descriptor_ = file->message_type(5);
156   static const int Info_offsets_[5] = {
157     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, version_),
158     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, timestamp_),
159     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, changeset_),
160     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, uid_),
161     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, user_sid_),
162   };
163   Info_reflection_ =
164     new ::google::protobuf::internal::GeneratedMessageReflection(
165       Info_descriptor_,
166       Info::default_instance_,
167       Info_offsets_,
168       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, _has_bits_[0]),
169       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Info, _unknown_fields_),
170       -1,
171       ::google::protobuf::DescriptorPool::generated_pool(),
172       ::google::protobuf::MessageFactory::generated_factory(),
173       sizeof(Info));
174   DenseInfo_descriptor_ = file->message_type(6);
175   static const int DenseInfo_offsets_[5] = {
176     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, version_),
177     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, timestamp_),
178     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, changeset_),
179     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, uid_),
180     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, user_sid_),
181   };
182   DenseInfo_reflection_ =
183     new ::google::protobuf::internal::GeneratedMessageReflection(
184       DenseInfo_descriptor_,
185       DenseInfo::default_instance_,
186       DenseInfo_offsets_,
187       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, _has_bits_[0]),
188       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseInfo, _unknown_fields_),
189       -1,
190       ::google::protobuf::DescriptorPool::generated_pool(),
191       ::google::protobuf::MessageFactory::generated_factory(),
192       sizeof(DenseInfo));
193   ChangeSet_descriptor_ = file->message_type(7);
194   static const int ChangeSet_offsets_[1] = {
195     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChangeSet, id_),
196   };
197   ChangeSet_reflection_ =
198     new ::google::protobuf::internal::GeneratedMessageReflection(
199       ChangeSet_descriptor_,
200       ChangeSet::default_instance_,
201       ChangeSet_offsets_,
202       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChangeSet, _has_bits_[0]),
203       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChangeSet, _unknown_fields_),
204       -1,
205       ::google::protobuf::DescriptorPool::generated_pool(),
206       ::google::protobuf::MessageFactory::generated_factory(),
207       sizeof(ChangeSet));
208   Node_descriptor_ = file->message_type(8);
209   static const int Node_offsets_[6] = {
210     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, id_),
211     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, keys_),
212     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, vals_),
213     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, info_),
214     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, lat_),
215     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, lon_),
216   };
217   Node_reflection_ =
218     new ::google::protobuf::internal::GeneratedMessageReflection(
219       Node_descriptor_,
220       Node::default_instance_,
221       Node_offsets_,
222       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, _has_bits_[0]),
223       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, _unknown_fields_),
224       -1,
225       ::google::protobuf::DescriptorPool::generated_pool(),
226       ::google::protobuf::MessageFactory::generated_factory(),
227       sizeof(Node));
228   DenseNodes_descriptor_ = file->message_type(9);
229   static const int DenseNodes_offsets_[5] = {
230     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, id_),
231     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, denseinfo_),
232     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, lat_),
233     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, lon_),
234     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, keys_vals_),
235   };
236   DenseNodes_reflection_ =
237     new ::google::protobuf::internal::GeneratedMessageReflection(
238       DenseNodes_descriptor_,
239       DenseNodes::default_instance_,
240       DenseNodes_offsets_,
241       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, _has_bits_[0]),
242       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DenseNodes, _unknown_fields_),
243       -1,
244       ::google::protobuf::DescriptorPool::generated_pool(),
245       ::google::protobuf::MessageFactory::generated_factory(),
246       sizeof(DenseNodes));
247   Way_descriptor_ = file->message_type(10);
248   static const int Way_offsets_[5] = {
249     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, id_),
250     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, keys_),
251     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, vals_),
252     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, info_),
253     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, refs_),
254   };
255   Way_reflection_ =
256     new ::google::protobuf::internal::GeneratedMessageReflection(
257       Way_descriptor_,
258       Way::default_instance_,
259       Way_offsets_,
260       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, _has_bits_[0]),
261       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Way, _unknown_fields_),
262       -1,
263       ::google::protobuf::DescriptorPool::generated_pool(),
264       ::google::protobuf::MessageFactory::generated_factory(),
265       sizeof(Way));
266   Relation_descriptor_ = file->message_type(11);
267   static const int Relation_offsets_[7] = {
268     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, id_),
269     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, keys_),
270     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, vals_),
271     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, info_),
272     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, roles_sid_),
273     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, memids_),
274     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, types_),
275   };
276   Relation_reflection_ =
277     new ::google::protobuf::internal::GeneratedMessageReflection(
278       Relation_descriptor_,
279       Relation::default_instance_,
280       Relation_offsets_,
281       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, _has_bits_[0]),
282       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Relation, _unknown_fields_),
283       -1,
284       ::google::protobuf::DescriptorPool::generated_pool(),
285       ::google::protobuf::MessageFactory::generated_factory(),
286       sizeof(Relation));
287   Relation_MemberType_descriptor_ = Relation_descriptor_->enum_type(0);
288 }
289
290 namespace {
291
292 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
293 inline void protobuf_AssignDescriptorsOnce() {
294   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
295                  &protobuf_AssignDesc_osmformat_2eproto);
296 }
297
298 void protobuf_RegisterTypes(const ::std::string&) {
299   protobuf_AssignDescriptorsOnce();
300   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
301     HeaderBlock_descriptor_, &HeaderBlock::default_instance());
302   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
303     HeaderBBox_descriptor_, &HeaderBBox::default_instance());
304   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
305     PrimitiveBlock_descriptor_, &PrimitiveBlock::default_instance());
306   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
307     PrimitiveGroup_descriptor_, &PrimitiveGroup::default_instance());
308   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
309     StringTable_descriptor_, &StringTable::default_instance());
310   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
311     Info_descriptor_, &Info::default_instance());
312   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
313     DenseInfo_descriptor_, &DenseInfo::default_instance());
314   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
315     ChangeSet_descriptor_, &ChangeSet::default_instance());
316   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
317     Node_descriptor_, &Node::default_instance());
318   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
319     DenseNodes_descriptor_, &DenseNodes::default_instance());
320   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
321     Way_descriptor_, &Way::default_instance());
322   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
323     Relation_descriptor_, &Relation::default_instance());
324 }
325
326 }  // namespace
327
328 void protobuf_ShutdownFile_osmformat_2eproto() {
329   delete HeaderBlock::default_instance_;
330   delete HeaderBlock_reflection_;
331   delete HeaderBBox::default_instance_;
332   delete HeaderBBox_reflection_;
333   delete PrimitiveBlock::default_instance_;
334   delete PrimitiveBlock_reflection_;
335   delete PrimitiveGroup::default_instance_;
336   delete PrimitiveGroup_reflection_;
337   delete StringTable::default_instance_;
338   delete StringTable_reflection_;
339   delete Info::default_instance_;
340   delete Info_reflection_;
341   delete DenseInfo::default_instance_;
342   delete DenseInfo_reflection_;
343   delete ChangeSet::default_instance_;
344   delete ChangeSet_reflection_;
345   delete Node::default_instance_;
346   delete Node_reflection_;
347   delete DenseNodes::default_instance_;
348   delete DenseNodes_reflection_;
349   delete Way::default_instance_;
350   delete Way_reflection_;
351   delete Relation::default_instance_;
352   delete Relation_reflection_;
353 }
354
355 void protobuf_AddDesc_osmformat_2eproto() {
356   static bool already_here = false;
357   if (already_here) return;
358   already_here = true;
359   GOOGLE_PROTOBUF_VERIFY_VERSION;
360
361   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
362     "\n\017osmformat.proto\022\003PBF\"\212\001\n\013HeaderBlock\022\035"
363     "\n\004bbox\030\001 \001(\0132\017.PBF.HeaderBBox\022\031\n\021require"
364     "d_features\030\004 \003(\t\022\031\n\021optional_features\030\005 "
365     "\003(\t\022\026\n\016writingprogram\030\020 \001(\t\022\016\n\006source\030\021 "
366     "\001(\t\"F\n\nHeaderBBox\022\014\n\004left\030\001 \002(\022\022\r\n\005right"
367     "\030\002 \002(\022\022\013\n\003top\030\003 \002(\022\022\016\n\006bottom\030\004 \002(\022\"\314\001\n\016"
368     "PrimitiveBlock\022%\n\013stringtable\030\001 \002(\0132\020.PB"
369     "F.StringTable\022+\n\016primitivegroup\030\002 \003(\0132\023."
370     "PBF.PrimitiveGroup\022\030\n\013granularity\030\021 \001(\005:"
371     "\003100\022\025\n\nlat_offset\030\023 \001(\003:\0010\022\025\n\nlon_offse"
372     "t\030\024 \001(\003:\0010\022\036\n\020date_granularity\030\022 \001(\005:\00410"
373     "00\"\250\001\n\016PrimitiveGroup\022\030\n\005nodes\030\001 \003(\0132\t.P"
374     "BF.Node\022\036\n\005dense\030\002 \001(\0132\017.PBF.DenseNodes\022"
375     "\026\n\004ways\030\003 \003(\0132\010.PBF.Way\022 \n\trelations\030\004 \003"
376     "(\0132\r.PBF.Relation\022\"\n\nchangesets\030\005 \003(\0132\016."
377     "PBF.ChangeSet\"\030\n\013StringTable\022\t\n\001s\030\001 \003(\014\""
378     "`\n\004Info\022\023\n\007version\030\001 \001(\005:\002-1\022\021\n\ttimestam"
379     "p\030\002 \001(\003\022\021\n\tchangeset\030\003 \001(\003\022\013\n\003uid\030\004 \001(\005\022"
380     "\020\n\010user_sid\030\005 \001(\005\"u\n\tDenseInfo\022\023\n\007versio"
381     "n\030\001 \003(\005B\002\020\001\022\025\n\ttimestamp\030\002 \003(\022B\002\020\001\022\025\n\tch"
382     "angeset\030\003 \003(\022B\002\020\001\022\017\n\003uid\030\004 \003(\021B\002\020\001\022\024\n\010us"
383     "er_sid\030\005 \003(\021B\002\020\001\"\027\n\tChangeSet\022\n\n\002id\030\001 \002("
384     "\003\"i\n\004Node\022\n\n\002id\030\001 \002(\022\022\020\n\004keys\030\002 \003(\rB\002\020\001\022"
385     "\020\n\004vals\030\003 \003(\rB\002\020\001\022\027\n\004info\030\004 \001(\0132\t.PBF.In"
386     "fo\022\013\n\003lat\030\010 \002(\022\022\013\n\003lon\030\t \002(\022\"x\n\nDenseNod"
387     "es\022\016\n\002id\030\001 \003(\022B\002\020\001\022!\n\tdenseinfo\030\005 \001(\0132\016."
388     "PBF.DenseInfo\022\017\n\003lat\030\010 \003(\022B\002\020\001\022\017\n\003lon\030\t "
389     "\003(\022B\002\020\001\022\025\n\tkeys_vals\030\n \003(\005B\002\020\001\"`\n\003Way\022\n\n"
390     "\002id\030\001 \002(\003\022\020\n\004keys\030\002 \003(\rB\002\020\001\022\020\n\004vals\030\003 \003("
391     "\rB\002\020\001\022\027\n\004info\030\004 \001(\0132\t.PBF.Info\022\020\n\004refs\030\010"
392     " \003(\022B\002\020\001\"\332\001\n\010Relation\022\n\n\002id\030\001 \002(\003\022\020\n\004key"
393     "s\030\002 \003(\rB\002\020\001\022\020\n\004vals\030\003 \003(\rB\002\020\001\022\027\n\004info\030\004 "
394     "\001(\0132\t.PBF.Info\022\025\n\troles_sid\030\010 \003(\005B\002\020\001\022\022\n"
395     "\006memids\030\t \003(\022B\002\020\001\022+\n\005types\030\n \003(\0162\030.PBF.R"
396     "elation.MemberTypeB\002\020\001\"-\n\nMemberType\022\010\n\004"
397     "NODE\020\000\022\007\n\003WAY\020\001\022\014\n\010RELATION\020\002", 1429);
398   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
399     "osmformat.proto", &protobuf_RegisterTypes);
400   HeaderBlock::default_instance_ = new HeaderBlock();
401   HeaderBBox::default_instance_ = new HeaderBBox();
402   PrimitiveBlock::default_instance_ = new PrimitiveBlock();
403   PrimitiveGroup::default_instance_ = new PrimitiveGroup();
404   StringTable::default_instance_ = new StringTable();
405   Info::default_instance_ = new Info();
406   DenseInfo::default_instance_ = new DenseInfo();
407   ChangeSet::default_instance_ = new ChangeSet();
408   Node::default_instance_ = new Node();
409   DenseNodes::default_instance_ = new DenseNodes();
410   Way::default_instance_ = new Way();
411   Relation::default_instance_ = new Relation();
412   HeaderBlock::default_instance_->InitAsDefaultInstance();
413   HeaderBBox::default_instance_->InitAsDefaultInstance();
414   PrimitiveBlock::default_instance_->InitAsDefaultInstance();
415   PrimitiveGroup::default_instance_->InitAsDefaultInstance();
416   StringTable::default_instance_->InitAsDefaultInstance();
417   Info::default_instance_->InitAsDefaultInstance();
418   DenseInfo::default_instance_->InitAsDefaultInstance();
419   ChangeSet::default_instance_->InitAsDefaultInstance();
420   Node::default_instance_->InitAsDefaultInstance();
421   DenseNodes::default_instance_->InitAsDefaultInstance();
422   Way::default_instance_->InitAsDefaultInstance();
423   Relation::default_instance_->InitAsDefaultInstance();
424   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_osmformat_2eproto);
425 }
426
427 // Force AddDescriptors() to be called at static initialization time.
428 struct StaticDescriptorInitializer_osmformat_2eproto {
429   StaticDescriptorInitializer_osmformat_2eproto() {
430     protobuf_AddDesc_osmformat_2eproto();
431   }
432 } static_descriptor_initializer_osmformat_2eproto_;
433
434
435 // ===================================================================
436
437 const ::std::string HeaderBlock::_default_writingprogram_;
438 const ::std::string HeaderBlock::_default_source_;
439 #ifndef _MSC_VER
440 const int HeaderBlock::kBboxFieldNumber;
441 const int HeaderBlock::kRequiredFeaturesFieldNumber;
442 const int HeaderBlock::kOptionalFeaturesFieldNumber;
443 const int HeaderBlock::kWritingprogramFieldNumber;
444 const int HeaderBlock::kSourceFieldNumber;
445 #endif  // !_MSC_VER
446
447 HeaderBlock::HeaderBlock()
448   : ::google::protobuf::Message() {
449   SharedCtor();
450 }
451
452 void HeaderBlock::InitAsDefaultInstance() {
453   bbox_ = const_cast< ::PBF::HeaderBBox*>(&::PBF::HeaderBBox::default_instance());
454 }
455
456 HeaderBlock::HeaderBlock(const HeaderBlock& from)
457   : ::google::protobuf::Message() {
458   SharedCtor();
459   MergeFrom(from);
460 }
461
462 void HeaderBlock::SharedCtor() {
463   _cached_size_ = 0;
464   bbox_ = NULL;
465   writingprogram_ = const_cast< ::std::string*>(&_default_writingprogram_);
466   source_ = const_cast< ::std::string*>(&_default_source_);
467   ::memset(_has_bits_, 0, sizeof(_has_bits_));
468 }
469
470 HeaderBlock::~HeaderBlock() {
471   SharedDtor();
472 }
473
474 void HeaderBlock::SharedDtor() {
475   if (writingprogram_ != &_default_writingprogram_) {
476     delete writingprogram_;
477   }
478   if (source_ != &_default_source_) {
479     delete source_;
480   }
481   if (this != default_instance_) {
482     delete bbox_;
483   }
484 }
485
486 void HeaderBlock::SetCachedSize(int size) const {
487   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
488   _cached_size_ = size;
489   GOOGLE_SAFE_CONCURRENT_WRITES_END();
490 }
491 const ::google::protobuf::Descriptor* HeaderBlock::descriptor() {
492   protobuf_AssignDescriptorsOnce();
493   return HeaderBlock_descriptor_;
494 }
495
496 const HeaderBlock& HeaderBlock::default_instance() {
497   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
498 }
499
500 HeaderBlock* HeaderBlock::default_instance_ = NULL;
501
502 HeaderBlock* HeaderBlock::New() const {
503   return new HeaderBlock;
504 }
505
506 void HeaderBlock::Clear() {
507   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
508     if (_has_bit(0)) {
509       if (bbox_ != NULL) bbox_->::PBF::HeaderBBox::Clear();
510     }
511     if (_has_bit(3)) {
512       if (writingprogram_ != &_default_writingprogram_) {
513         writingprogram_->clear();
514       }
515     }
516     if (_has_bit(4)) {
517       if (source_ != &_default_source_) {
518         source_->clear();
519       }
520     }
521   }
522   required_features_.Clear();
523   optional_features_.Clear();
524   ::memset(_has_bits_, 0, sizeof(_has_bits_));
525   mutable_unknown_fields()->Clear();
526 }
527
528 bool HeaderBlock::MergePartialFromCodedStream(
529     ::google::protobuf::io::CodedInputStream* input) {
530 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
531   ::google::protobuf::uint32 tag;
532   while ((tag = input->ReadTag()) != 0) {
533     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
534       // optional .PBF.HeaderBBox bbox = 1;
535       case 1: {
536         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
537             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
538           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
539                input, mutable_bbox()));
540         } else {
541           goto handle_uninterpreted;
542         }
543         if (input->ExpectTag(34)) goto parse_required_features;
544         break;
545       }
546       
547       // repeated string required_features = 4;
548       case 4: {
549         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
550             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
551          parse_required_features:
552           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
553                 input, this->add_required_features()));
554           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
555             this->required_features(0).data(), this->required_features(0).length(),
556             ::google::protobuf::internal::WireFormat::PARSE);
557         } else {
558           goto handle_uninterpreted;
559         }
560         if (input->ExpectTag(34)) goto parse_required_features;
561         if (input->ExpectTag(42)) goto parse_optional_features;
562         break;
563       }
564       
565       // repeated string optional_features = 5;
566       case 5: {
567         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
568             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
569          parse_optional_features:
570           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
571                 input, this->add_optional_features()));
572           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
573             this->optional_features(0).data(), this->optional_features(0).length(),
574             ::google::protobuf::internal::WireFormat::PARSE);
575         } else {
576           goto handle_uninterpreted;
577         }
578         if (input->ExpectTag(42)) goto parse_optional_features;
579         if (input->ExpectTag(130)) goto parse_writingprogram;
580         break;
581       }
582       
583       // optional string writingprogram = 16;
584       case 16: {
585         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
586             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
587          parse_writingprogram:
588           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
589                 input, this->mutable_writingprogram()));
590           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
591             this->writingprogram().data(), this->writingprogram().length(),
592             ::google::protobuf::internal::WireFormat::PARSE);
593         } else {
594           goto handle_uninterpreted;
595         }
596         if (input->ExpectTag(138)) goto parse_source;
597         break;
598       }
599       
600       // optional string source = 17;
601       case 17: {
602         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
603             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
604          parse_source:
605           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
606                 input, this->mutable_source()));
607           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
608             this->source().data(), this->source().length(),
609             ::google::protobuf::internal::WireFormat::PARSE);
610         } else {
611           goto handle_uninterpreted;
612         }
613         if (input->ExpectAtEnd()) return true;
614         break;
615       }
616       
617       default: {
618       handle_uninterpreted:
619         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
620             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
621           return true;
622         }
623         DO_(::google::protobuf::internal::WireFormat::SkipField(
624               input, tag, mutable_unknown_fields()));
625         break;
626       }
627     }
628   }
629   return true;
630 #undef DO_
631 }
632
633 void HeaderBlock::SerializeWithCachedSizes(
634     ::google::protobuf::io::CodedOutputStream* output) const {
635   // optional .PBF.HeaderBBox bbox = 1;
636   if (_has_bit(0)) {
637     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
638       1, this->bbox(), output);
639   }
640   
641   // repeated string required_features = 4;
642   for (int i = 0; i < this->required_features_size(); i++) {
643   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
644     this->required_features(i).data(), this->required_features(i).length(),
645     ::google::protobuf::internal::WireFormat::SERIALIZE);
646     ::google::protobuf::internal::WireFormatLite::WriteString(
647       4, this->required_features(i), output);
648   }
649   
650   // repeated string optional_features = 5;
651   for (int i = 0; i < this->optional_features_size(); i++) {
652   ::google::protobuf::internal::WireFormat::VerifyUTF8String(
653     this->optional_features(i).data(), this->optional_features(i).length(),
654     ::google::protobuf::internal::WireFormat::SERIALIZE);
655     ::google::protobuf::internal::WireFormatLite::WriteString(
656       5, this->optional_features(i), output);
657   }
658   
659   // optional string writingprogram = 16;
660   if (_has_bit(3)) {
661     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
662       this->writingprogram().data(), this->writingprogram().length(),
663       ::google::protobuf::internal::WireFormat::SERIALIZE);
664     ::google::protobuf::internal::WireFormatLite::WriteString(
665       16, this->writingprogram(), output);
666   }
667   
668   // optional string source = 17;
669   if (_has_bit(4)) {
670     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
671       this->source().data(), this->source().length(),
672       ::google::protobuf::internal::WireFormat::SERIALIZE);
673     ::google::protobuf::internal::WireFormatLite::WriteString(
674       17, this->source(), output);
675   }
676   
677   if (!unknown_fields().empty()) {
678     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
679         unknown_fields(), output);
680   }
681 }
682
683 ::google::protobuf::uint8* HeaderBlock::SerializeWithCachedSizesToArray(
684     ::google::protobuf::uint8* target) const {
685   // optional .PBF.HeaderBBox bbox = 1;
686   if (_has_bit(0)) {
687     target = ::google::protobuf::internal::WireFormatLite::
688       WriteMessageNoVirtualToArray(
689         1, this->bbox(), target);
690   }
691   
692   // repeated string required_features = 4;
693   for (int i = 0; i < this->required_features_size(); i++) {
694     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
695       this->required_features(i).data(), this->required_features(i).length(),
696       ::google::protobuf::internal::WireFormat::SERIALIZE);
697     target = ::google::protobuf::internal::WireFormatLite::
698       WriteStringToArray(4, this->required_features(i), target);
699   }
700   
701   // repeated string optional_features = 5;
702   for (int i = 0; i < this->optional_features_size(); i++) {
703     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
704       this->optional_features(i).data(), this->optional_features(i).length(),
705       ::google::protobuf::internal::WireFormat::SERIALIZE);
706     target = ::google::protobuf::internal::WireFormatLite::
707       WriteStringToArray(5, this->optional_features(i), target);
708   }
709   
710   // optional string writingprogram = 16;
711   if (_has_bit(3)) {
712     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
713       this->writingprogram().data(), this->writingprogram().length(),
714       ::google::protobuf::internal::WireFormat::SERIALIZE);
715     target =
716       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
717         16, this->writingprogram(), target);
718   }
719   
720   // optional string source = 17;
721   if (_has_bit(4)) {
722     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
723       this->source().data(), this->source().length(),
724       ::google::protobuf::internal::WireFormat::SERIALIZE);
725     target =
726       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
727         17, this->source(), target);
728   }
729   
730   if (!unknown_fields().empty()) {
731     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
732         unknown_fields(), target);
733   }
734   return target;
735 }
736
737 int HeaderBlock::ByteSize() const {
738   int total_size = 0;
739   
740   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
741     // optional .PBF.HeaderBBox bbox = 1;
742     if (has_bbox()) {
743       total_size += 1 +
744         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
745           this->bbox());
746     }
747     
748     // optional string writingprogram = 16;
749     if (has_writingprogram()) {
750       total_size += 2 +
751         ::google::protobuf::internal::WireFormatLite::StringSize(
752           this->writingprogram());
753     }
754     
755     // optional string source = 17;
756     if (has_source()) {
757       total_size += 2 +
758         ::google::protobuf::internal::WireFormatLite::StringSize(
759           this->source());
760     }
761     
762   }
763   // repeated string required_features = 4;
764   total_size += 1 * this->required_features_size();
765   for (int i = 0; i < this->required_features_size(); i++) {
766     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
767       this->required_features(i));
768   }
769   
770   // repeated string optional_features = 5;
771   total_size += 1 * this->optional_features_size();
772   for (int i = 0; i < this->optional_features_size(); i++) {
773     total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
774       this->optional_features(i));
775   }
776   
777   if (!unknown_fields().empty()) {
778     total_size +=
779       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
780         unknown_fields());
781   }
782   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
783   _cached_size_ = total_size;
784   GOOGLE_SAFE_CONCURRENT_WRITES_END();
785   return total_size;
786 }
787
788 void HeaderBlock::MergeFrom(const ::google::protobuf::Message& from) {
789   GOOGLE_CHECK_NE(&from, this);
790   const HeaderBlock* source =
791     ::google::protobuf::internal::dynamic_cast_if_available<const HeaderBlock*>(
792       &from);
793   if (source == NULL) {
794     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
795   } else {
796     MergeFrom(*source);
797   }
798 }
799
800 void HeaderBlock::MergeFrom(const HeaderBlock& from) {
801   GOOGLE_CHECK_NE(&from, this);
802   required_features_.MergeFrom(from.required_features_);
803   optional_features_.MergeFrom(from.optional_features_);
804   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
805     if (from._has_bit(0)) {
806       mutable_bbox()->::PBF::HeaderBBox::MergeFrom(from.bbox());
807     }
808     if (from._has_bit(3)) {
809       set_writingprogram(from.writingprogram());
810     }
811     if (from._has_bit(4)) {
812       set_source(from.source());
813     }
814   }
815   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
816 }
817
818 void HeaderBlock::CopyFrom(const ::google::protobuf::Message& from) {
819   if (&from == this) return;
820   Clear();
821   MergeFrom(from);
822 }
823
824 void HeaderBlock::CopyFrom(const HeaderBlock& from) {
825   if (&from == this) return;
826   Clear();
827   MergeFrom(from);
828 }
829
830 bool HeaderBlock::IsInitialized() const {
831   
832   if (has_bbox()) {
833     if (!this->bbox().IsInitialized()) return false;
834   }
835   return true;
836 }
837
838 void HeaderBlock::Swap(HeaderBlock* other) {
839   if (other != this) {
840     std::swap(bbox_, other->bbox_);
841     required_features_.Swap(&other->required_features_);
842     optional_features_.Swap(&other->optional_features_);
843     std::swap(writingprogram_, other->writingprogram_);
844     std::swap(source_, other->source_);
845     std::swap(_has_bits_[0], other->_has_bits_[0]);
846     _unknown_fields_.Swap(&other->_unknown_fields_);
847     std::swap(_cached_size_, other->_cached_size_);
848   }
849 }
850
851 ::google::protobuf::Metadata HeaderBlock::GetMetadata() const {
852   protobuf_AssignDescriptorsOnce();
853   ::google::protobuf::Metadata metadata;
854   metadata.descriptor = HeaderBlock_descriptor_;
855   metadata.reflection = HeaderBlock_reflection_;
856   return metadata;
857 }
858
859
860 // ===================================================================
861
862 #ifndef _MSC_VER
863 const int HeaderBBox::kLeftFieldNumber;
864 const int HeaderBBox::kRightFieldNumber;
865 const int HeaderBBox::kTopFieldNumber;
866 const int HeaderBBox::kBottomFieldNumber;
867 #endif  // !_MSC_VER
868
869 HeaderBBox::HeaderBBox()
870   : ::google::protobuf::Message() {
871   SharedCtor();
872 }
873
874 void HeaderBBox::InitAsDefaultInstance() {
875 }
876
877 HeaderBBox::HeaderBBox(const HeaderBBox& from)
878   : ::google::protobuf::Message() {
879   SharedCtor();
880   MergeFrom(from);
881 }
882
883 void HeaderBBox::SharedCtor() {
884   _cached_size_ = 0;
885   left_ = GOOGLE_LONGLONG(0);
886   right_ = GOOGLE_LONGLONG(0);
887   top_ = GOOGLE_LONGLONG(0);
888   bottom_ = GOOGLE_LONGLONG(0);
889   ::memset(_has_bits_, 0, sizeof(_has_bits_));
890 }
891
892 HeaderBBox::~HeaderBBox() {
893   SharedDtor();
894 }
895
896 void HeaderBBox::SharedDtor() {
897   if (this != default_instance_) {
898   }
899 }
900
901 void HeaderBBox::SetCachedSize(int size) const {
902   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
903   _cached_size_ = size;
904   GOOGLE_SAFE_CONCURRENT_WRITES_END();
905 }
906 const ::google::protobuf::Descriptor* HeaderBBox::descriptor() {
907   protobuf_AssignDescriptorsOnce();
908   return HeaderBBox_descriptor_;
909 }
910
911 const HeaderBBox& HeaderBBox::default_instance() {
912   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
913 }
914
915 HeaderBBox* HeaderBBox::default_instance_ = NULL;
916
917 HeaderBBox* HeaderBBox::New() const {
918   return new HeaderBBox;
919 }
920
921 void HeaderBBox::Clear() {
922   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
923     left_ = GOOGLE_LONGLONG(0);
924     right_ = GOOGLE_LONGLONG(0);
925     top_ = GOOGLE_LONGLONG(0);
926     bottom_ = GOOGLE_LONGLONG(0);
927   }
928   ::memset(_has_bits_, 0, sizeof(_has_bits_));
929   mutable_unknown_fields()->Clear();
930 }
931
932 bool HeaderBBox::MergePartialFromCodedStream(
933     ::google::protobuf::io::CodedInputStream* input) {
934 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
935   ::google::protobuf::uint32 tag;
936   while ((tag = input->ReadTag()) != 0) {
937     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
938       // required sint64 left = 1;
939       case 1: {
940         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
941             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
942           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
943                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
944                  input, &left_)));
945           _set_bit(0);
946         } else {
947           goto handle_uninterpreted;
948         }
949         if (input->ExpectTag(16)) goto parse_right;
950         break;
951       }
952       
953       // required sint64 right = 2;
954       case 2: {
955         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
956             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
957          parse_right:
958           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
959                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
960                  input, &right_)));
961           _set_bit(1);
962         } else {
963           goto handle_uninterpreted;
964         }
965         if (input->ExpectTag(24)) goto parse_top;
966         break;
967       }
968       
969       // required sint64 top = 3;
970       case 3: {
971         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
972             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
973          parse_top:
974           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
975                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
976                  input, &top_)));
977           _set_bit(2);
978         } else {
979           goto handle_uninterpreted;
980         }
981         if (input->ExpectTag(32)) goto parse_bottom;
982         break;
983       }
984       
985       // required sint64 bottom = 4;
986       case 4: {
987         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
988             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
989          parse_bottom:
990           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
991                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
992                  input, &bottom_)));
993           _set_bit(3);
994         } else {
995           goto handle_uninterpreted;
996         }
997         if (input->ExpectAtEnd()) return true;
998         break;
999       }
1000       
1001       default: {
1002       handle_uninterpreted:
1003         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1004             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1005           return true;
1006         }
1007         DO_(::google::protobuf::internal::WireFormat::SkipField(
1008               input, tag, mutable_unknown_fields()));
1009         break;
1010       }
1011     }
1012   }
1013   return true;
1014 #undef DO_
1015 }
1016
1017 void HeaderBBox::SerializeWithCachedSizes(
1018     ::google::protobuf::io::CodedOutputStream* output) const {
1019   // required sint64 left = 1;
1020   if (_has_bit(0)) {
1021     ::google::protobuf::internal::WireFormatLite::WriteSInt64(1, this->left(), output);
1022   }
1023   
1024   // required sint64 right = 2;
1025   if (_has_bit(1)) {
1026     ::google::protobuf::internal::WireFormatLite::WriteSInt64(2, this->right(), output);
1027   }
1028   
1029   // required sint64 top = 3;
1030   if (_has_bit(2)) {
1031     ::google::protobuf::internal::WireFormatLite::WriteSInt64(3, this->top(), output);
1032   }
1033   
1034   // required sint64 bottom = 4;
1035   if (_has_bit(3)) {
1036     ::google::protobuf::internal::WireFormatLite::WriteSInt64(4, this->bottom(), output);
1037   }
1038   
1039   if (!unknown_fields().empty()) {
1040     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1041         unknown_fields(), output);
1042   }
1043 }
1044
1045 ::google::protobuf::uint8* HeaderBBox::SerializeWithCachedSizesToArray(
1046     ::google::protobuf::uint8* target) const {
1047   // required sint64 left = 1;
1048   if (_has_bit(0)) {
1049     target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(1, this->left(), target);
1050   }
1051   
1052   // required sint64 right = 2;
1053   if (_has_bit(1)) {
1054     target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(2, this->right(), target);
1055   }
1056   
1057   // required sint64 top = 3;
1058   if (_has_bit(2)) {
1059     target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(3, this->top(), target);
1060   }
1061   
1062   // required sint64 bottom = 4;
1063   if (_has_bit(3)) {
1064     target = ::google::protobuf::internal::WireFormatLite::WriteSInt64ToArray(4, this->bottom(), target);
1065   }
1066   
1067   if (!unknown_fields().empty()) {
1068     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1069         unknown_fields(), target);
1070   }
1071   return target;
1072 }
1073
1074 int HeaderBBox::ByteSize() const {
1075   int total_size = 0;
1076   
1077   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1078     // required sint64 left = 1;
1079     if (has_left()) {
1080       total_size += 1 +
1081         ::google::protobuf::internal::WireFormatLite::SInt64Size(
1082           this->left());
1083     }
1084     
1085     // required sint64 right = 2;
1086     if (has_right()) {
1087       total_size += 1 +
1088         ::google::protobuf::internal::WireFormatLite::SInt64Size(
1089           this->right());
1090     }
1091     
1092     // required sint64 top = 3;
1093     if (has_top()) {
1094       total_size += 1 +
1095         ::google::protobuf::internal::WireFormatLite::SInt64Size(
1096           this->top());
1097     }
1098     
1099     // required sint64 bottom = 4;
1100     if (has_bottom()) {
1101       total_size += 1 +
1102         ::google::protobuf::internal::WireFormatLite::SInt64Size(
1103           this->bottom());
1104     }
1105     
1106   }
1107   if (!unknown_fields().empty()) {
1108     total_size +=
1109       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1110         unknown_fields());
1111   }
1112   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1113   _cached_size_ = total_size;
1114   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1115   return total_size;
1116 }
1117
1118 void HeaderBBox::MergeFrom(const ::google::protobuf::Message& from) {
1119   GOOGLE_CHECK_NE(&from, this);
1120   const HeaderBBox* source =
1121     ::google::protobuf::internal::dynamic_cast_if_available<const HeaderBBox*>(
1122       &from);
1123   if (source == NULL) {
1124     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1125   } else {
1126     MergeFrom(*source);
1127   }
1128 }
1129
1130 void HeaderBBox::MergeFrom(const HeaderBBox& from) {
1131   GOOGLE_CHECK_NE(&from, this);
1132   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1133     if (from._has_bit(0)) {
1134       set_left(from.left());
1135     }
1136     if (from._has_bit(1)) {
1137       set_right(from.right());
1138     }
1139     if (from._has_bit(2)) {
1140       set_top(from.top());
1141     }
1142     if (from._has_bit(3)) {
1143       set_bottom(from.bottom());
1144     }
1145   }
1146   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1147 }
1148
1149 void HeaderBBox::CopyFrom(const ::google::protobuf::Message& from) {
1150   if (&from == this) return;
1151   Clear();
1152   MergeFrom(from);
1153 }
1154
1155 void HeaderBBox::CopyFrom(const HeaderBBox& from) {
1156   if (&from == this) return;
1157   Clear();
1158   MergeFrom(from);
1159 }
1160
1161 bool HeaderBBox::IsInitialized() const {
1162   if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
1163   
1164   return true;
1165 }
1166
1167 void HeaderBBox::Swap(HeaderBBox* other) {
1168   if (other != this) {
1169     std::swap(left_, other->left_);
1170     std::swap(right_, other->right_);
1171     std::swap(top_, other->top_);
1172     std::swap(bottom_, other->bottom_);
1173     std::swap(_has_bits_[0], other->_has_bits_[0]);
1174     _unknown_fields_.Swap(&other->_unknown_fields_);
1175     std::swap(_cached_size_, other->_cached_size_);
1176   }
1177 }
1178
1179 ::google::protobuf::Metadata HeaderBBox::GetMetadata() const {
1180   protobuf_AssignDescriptorsOnce();
1181   ::google::protobuf::Metadata metadata;
1182   metadata.descriptor = HeaderBBox_descriptor_;
1183   metadata.reflection = HeaderBBox_reflection_;
1184   return metadata;
1185 }
1186
1187
1188 // ===================================================================
1189
1190 #ifndef _MSC_VER
1191 const int PrimitiveBlock::kStringtableFieldNumber;
1192 const int PrimitiveBlock::kPrimitivegroupFieldNumber;
1193 const int PrimitiveBlock::kGranularityFieldNumber;
1194 const int PrimitiveBlock::kLatOffsetFieldNumber;
1195 const int PrimitiveBlock::kLonOffsetFieldNumber;
1196 const int PrimitiveBlock::kDateGranularityFieldNumber;
1197 #endif  // !_MSC_VER
1198
1199 PrimitiveBlock::PrimitiveBlock()
1200   : ::google::protobuf::Message() {
1201   SharedCtor();
1202 }
1203
1204 void PrimitiveBlock::InitAsDefaultInstance() {
1205   stringtable_ = const_cast< ::PBF::StringTable*>(&::PBF::StringTable::default_instance());
1206 }
1207
1208 PrimitiveBlock::PrimitiveBlock(const PrimitiveBlock& from)
1209   : ::google::protobuf::Message() {
1210   SharedCtor();
1211   MergeFrom(from);
1212 }
1213
1214 void PrimitiveBlock::SharedCtor() {
1215   _cached_size_ = 0;
1216   stringtable_ = NULL;
1217   granularity_ = 100;
1218   lat_offset_ = GOOGLE_LONGLONG(0);
1219   lon_offset_ = GOOGLE_LONGLONG(0);
1220   date_granularity_ = 1000;
1221   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1222 }
1223
1224 PrimitiveBlock::~PrimitiveBlock() {
1225   SharedDtor();
1226 }
1227
1228 void PrimitiveBlock::SharedDtor() {
1229   if (this != default_instance_) {
1230     delete stringtable_;
1231   }
1232 }
1233
1234 void PrimitiveBlock::SetCachedSize(int size) const {
1235   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1236   _cached_size_ = size;
1237   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1238 }
1239 const ::google::protobuf::Descriptor* PrimitiveBlock::descriptor() {
1240   protobuf_AssignDescriptorsOnce();
1241   return PrimitiveBlock_descriptor_;
1242 }
1243
1244 const PrimitiveBlock& PrimitiveBlock::default_instance() {
1245   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
1246 }
1247
1248 PrimitiveBlock* PrimitiveBlock::default_instance_ = NULL;
1249
1250 PrimitiveBlock* PrimitiveBlock::New() const {
1251   return new PrimitiveBlock;
1252 }
1253
1254 void PrimitiveBlock::Clear() {
1255   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1256     if (_has_bit(0)) {
1257       if (stringtable_ != NULL) stringtable_->::PBF::StringTable::Clear();
1258     }
1259     granularity_ = 100;
1260     lat_offset_ = GOOGLE_LONGLONG(0);
1261     lon_offset_ = GOOGLE_LONGLONG(0);
1262     date_granularity_ = 1000;
1263   }
1264   primitivegroup_.Clear();
1265   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1266   mutable_unknown_fields()->Clear();
1267 }
1268
1269 bool PrimitiveBlock::MergePartialFromCodedStream(
1270     ::google::protobuf::io::CodedInputStream* input) {
1271 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1272   ::google::protobuf::uint32 tag;
1273   while ((tag = input->ReadTag()) != 0) {
1274     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1275       // required .PBF.StringTable stringtable = 1;
1276       case 1: {
1277         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1278             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1279           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1280                input, mutable_stringtable()));
1281         } else {
1282           goto handle_uninterpreted;
1283         }
1284         if (input->ExpectTag(18)) goto parse_primitivegroup;
1285         break;
1286       }
1287       
1288       // repeated .PBF.PrimitiveGroup primitivegroup = 2;
1289       case 2: {
1290         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1291             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1292          parse_primitivegroup:
1293           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1294                 input, add_primitivegroup()));
1295         } else {
1296           goto handle_uninterpreted;
1297         }
1298         if (input->ExpectTag(18)) goto parse_primitivegroup;
1299         if (input->ExpectTag(136)) goto parse_granularity;
1300         break;
1301       }
1302       
1303       // optional int32 granularity = 17 [default = 100];
1304       case 17: {
1305         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1306             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1307          parse_granularity:
1308           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1309                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1310                  input, &granularity_)));
1311           _set_bit(2);
1312         } else {
1313           goto handle_uninterpreted;
1314         }
1315         if (input->ExpectTag(144)) goto parse_date_granularity;
1316         break;
1317       }
1318       
1319       // optional int32 date_granularity = 18 [default = 1000];
1320       case 18: {
1321         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1322             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1323          parse_date_granularity:
1324           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1325                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
1326                  input, &date_granularity_)));
1327           _set_bit(5);
1328         } else {
1329           goto handle_uninterpreted;
1330         }
1331         if (input->ExpectTag(152)) goto parse_lat_offset;
1332         break;
1333       }
1334       
1335       // optional int64 lat_offset = 19 [default = 0];
1336       case 19: {
1337         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1338             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1339          parse_lat_offset:
1340           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1341                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
1342                  input, &lat_offset_)));
1343           _set_bit(3);
1344         } else {
1345           goto handle_uninterpreted;
1346         }
1347         if (input->ExpectTag(160)) goto parse_lon_offset;
1348         break;
1349       }
1350       
1351       // optional int64 lon_offset = 20 [default = 0];
1352       case 20: {
1353         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1354             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1355          parse_lon_offset:
1356           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
1357                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
1358                  input, &lon_offset_)));
1359           _set_bit(4);
1360         } else {
1361           goto handle_uninterpreted;
1362         }
1363         if (input->ExpectAtEnd()) return true;
1364         break;
1365       }
1366       
1367       default: {
1368       handle_uninterpreted:
1369         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1370             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1371           return true;
1372         }
1373         DO_(::google::protobuf::internal::WireFormat::SkipField(
1374               input, tag, mutable_unknown_fields()));
1375         break;
1376       }
1377     }
1378   }
1379   return true;
1380 #undef DO_
1381 }
1382
1383 void PrimitiveBlock::SerializeWithCachedSizes(
1384     ::google::protobuf::io::CodedOutputStream* output) const {
1385   // required .PBF.StringTable stringtable = 1;
1386   if (_has_bit(0)) {
1387     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1388       1, this->stringtable(), output);
1389   }
1390   
1391   // repeated .PBF.PrimitiveGroup primitivegroup = 2;
1392   for (int i = 0; i < this->primitivegroup_size(); i++) {
1393     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1394       2, this->primitivegroup(i), output);
1395   }
1396   
1397   // optional int32 granularity = 17 [default = 100];
1398   if (_has_bit(2)) {
1399     ::google::protobuf::internal::WireFormatLite::WriteInt32(17, this->granularity(), output);
1400   }
1401   
1402   // optional int32 date_granularity = 18 [default = 1000];
1403   if (_has_bit(5)) {
1404     ::google::protobuf::internal::WireFormatLite::WriteInt32(18, this->date_granularity(), output);
1405   }
1406   
1407   // optional int64 lat_offset = 19 [default = 0];
1408   if (_has_bit(3)) {
1409     ::google::protobuf::internal::WireFormatLite::WriteInt64(19, this->lat_offset(), output);
1410   }
1411   
1412   // optional int64 lon_offset = 20 [default = 0];
1413   if (_has_bit(4)) {
1414     ::google::protobuf::internal::WireFormatLite::WriteInt64(20, this->lon_offset(), output);
1415   }
1416   
1417   if (!unknown_fields().empty()) {
1418     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1419         unknown_fields(), output);
1420   }
1421 }
1422
1423 ::google::protobuf::uint8* PrimitiveBlock::SerializeWithCachedSizesToArray(
1424     ::google::protobuf::uint8* target) const {
1425   // required .PBF.StringTable stringtable = 1;
1426   if (_has_bit(0)) {
1427     target = ::google::protobuf::internal::WireFormatLite::
1428       WriteMessageNoVirtualToArray(
1429         1, this->stringtable(), target);
1430   }
1431   
1432   // repeated .PBF.PrimitiveGroup primitivegroup = 2;
1433   for (int i = 0; i < this->primitivegroup_size(); i++) {
1434     target = ::google::protobuf::internal::WireFormatLite::
1435       WriteMessageNoVirtualToArray(
1436         2, this->primitivegroup(i), target);
1437   }
1438   
1439   // optional int32 granularity = 17 [default = 100];
1440   if (_has_bit(2)) {
1441     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(17, this->granularity(), target);
1442   }
1443   
1444   // optional int32 date_granularity = 18 [default = 1000];
1445   if (_has_bit(5)) {
1446     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(18, this->date_granularity(), target);
1447   }
1448   
1449   // optional int64 lat_offset = 19 [default = 0];
1450   if (_has_bit(3)) {
1451     target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(19, this->lat_offset(), target);
1452   }
1453   
1454   // optional int64 lon_offset = 20 [default = 0];
1455   if (_has_bit(4)) {
1456     target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(20, this->lon_offset(), target);
1457   }
1458   
1459   if (!unknown_fields().empty()) {
1460     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1461         unknown_fields(), target);
1462   }
1463   return target;
1464 }
1465
1466 int PrimitiveBlock::ByteSize() const {
1467   int total_size = 0;
1468   
1469   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1470     // required .PBF.StringTable stringtable = 1;
1471     if (has_stringtable()) {
1472       total_size += 1 +
1473         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1474           this->stringtable());
1475     }
1476     
1477     // optional int32 granularity = 17 [default = 100];
1478     if (has_granularity()) {
1479       total_size += 2 +
1480         ::google::protobuf::internal::WireFormatLite::Int32Size(
1481           this->granularity());
1482     }
1483     
1484     // optional int64 lat_offset = 19 [default = 0];
1485     if (has_lat_offset()) {
1486       total_size += 2 +
1487         ::google::protobuf::internal::WireFormatLite::Int64Size(
1488           this->lat_offset());
1489     }
1490     
1491     // optional int64 lon_offset = 20 [default = 0];
1492     if (has_lon_offset()) {
1493       total_size += 2 +
1494         ::google::protobuf::internal::WireFormatLite::Int64Size(
1495           this->lon_offset());
1496     }
1497     
1498     // optional int32 date_granularity = 18 [default = 1000];
1499     if (has_date_granularity()) {
1500       total_size += 2 +
1501         ::google::protobuf::internal::WireFormatLite::Int32Size(
1502           this->date_granularity());
1503     }
1504     
1505   }
1506   // repeated .PBF.PrimitiveGroup primitivegroup = 2;
1507   total_size += 1 * this->primitivegroup_size();
1508   for (int i = 0; i < this->primitivegroup_size(); i++) {
1509     total_size +=
1510       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1511         this->primitivegroup(i));
1512   }
1513   
1514   if (!unknown_fields().empty()) {
1515     total_size +=
1516       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1517         unknown_fields());
1518   }
1519   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1520   _cached_size_ = total_size;
1521   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1522   return total_size;
1523 }
1524
1525 void PrimitiveBlock::MergeFrom(const ::google::protobuf::Message& from) {
1526   GOOGLE_CHECK_NE(&from, this);
1527   const PrimitiveBlock* source =
1528     ::google::protobuf::internal::dynamic_cast_if_available<const PrimitiveBlock*>(
1529       &from);
1530   if (source == NULL) {
1531     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1532   } else {
1533     MergeFrom(*source);
1534   }
1535 }
1536
1537 void PrimitiveBlock::MergeFrom(const PrimitiveBlock& from) {
1538   GOOGLE_CHECK_NE(&from, this);
1539   primitivegroup_.MergeFrom(from.primitivegroup_);
1540   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1541     if (from._has_bit(0)) {
1542       mutable_stringtable()->::PBF::StringTable::MergeFrom(from.stringtable());
1543     }
1544     if (from._has_bit(2)) {
1545       set_granularity(from.granularity());
1546     }
1547     if (from._has_bit(3)) {
1548       set_lat_offset(from.lat_offset());
1549     }
1550     if (from._has_bit(4)) {
1551       set_lon_offset(from.lon_offset());
1552     }
1553     if (from._has_bit(5)) {
1554       set_date_granularity(from.date_granularity());
1555     }
1556   }
1557   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1558 }
1559
1560 void PrimitiveBlock::CopyFrom(const ::google::protobuf::Message& from) {
1561   if (&from == this) return;
1562   Clear();
1563   MergeFrom(from);
1564 }
1565
1566 void PrimitiveBlock::CopyFrom(const PrimitiveBlock& from) {
1567   if (&from == this) return;
1568   Clear();
1569   MergeFrom(from);
1570 }
1571
1572 bool PrimitiveBlock::IsInitialized() const {
1573   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
1574   
1575   for (int i = 0; i < primitivegroup_size(); i++) {
1576     if (!this->primitivegroup(i).IsInitialized()) return false;
1577   }
1578   return true;
1579 }
1580
1581 void PrimitiveBlock::Swap(PrimitiveBlock* other) {
1582   if (other != this) {
1583     std::swap(stringtable_, other->stringtable_);
1584     primitivegroup_.Swap(&other->primitivegroup_);
1585     std::swap(granularity_, other->granularity_);
1586     std::swap(lat_offset_, other->lat_offset_);
1587     std::swap(lon_offset_, other->lon_offset_);
1588     std::swap(date_granularity_, other->date_granularity_);
1589     std::swap(_has_bits_[0], other->_has_bits_[0]);
1590     _unknown_fields_.Swap(&other->_unknown_fields_);
1591     std::swap(_cached_size_, other->_cached_size_);
1592   }
1593 }
1594
1595 ::google::protobuf::Metadata PrimitiveBlock::GetMetadata() const {
1596   protobuf_AssignDescriptorsOnce();
1597   ::google::protobuf::Metadata metadata;
1598   metadata.descriptor = PrimitiveBlock_descriptor_;
1599   metadata.reflection = PrimitiveBlock_reflection_;
1600   return metadata;
1601 }
1602
1603
1604 // ===================================================================
1605
1606 #ifndef _MSC_VER
1607 const int PrimitiveGroup::kNodesFieldNumber;
1608 const int PrimitiveGroup::kDenseFieldNumber;
1609 const int PrimitiveGroup::kWaysFieldNumber;
1610 const int PrimitiveGroup::kRelationsFieldNumber;
1611 const int PrimitiveGroup::kChangesetsFieldNumber;
1612 #endif  // !_MSC_VER
1613
1614 PrimitiveGroup::PrimitiveGroup()
1615   : ::google::protobuf::Message() {
1616   SharedCtor();
1617 }
1618
1619 void PrimitiveGroup::InitAsDefaultInstance() {
1620   dense_ = const_cast< ::PBF::DenseNodes*>(&::PBF::DenseNodes::default_instance());
1621 }
1622
1623 PrimitiveGroup::PrimitiveGroup(const PrimitiveGroup& from)
1624   : ::google::protobuf::Message() {
1625   SharedCtor();
1626   MergeFrom(from);
1627 }
1628
1629 void PrimitiveGroup::SharedCtor() {
1630   _cached_size_ = 0;
1631   dense_ = NULL;
1632   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1633 }
1634
1635 PrimitiveGroup::~PrimitiveGroup() {
1636   SharedDtor();
1637 }
1638
1639 void PrimitiveGroup::SharedDtor() {
1640   if (this != default_instance_) {
1641     delete dense_;
1642   }
1643 }
1644
1645 void PrimitiveGroup::SetCachedSize(int size) const {
1646   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1647   _cached_size_ = size;
1648   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1649 }
1650 const ::google::protobuf::Descriptor* PrimitiveGroup::descriptor() {
1651   protobuf_AssignDescriptorsOnce();
1652   return PrimitiveGroup_descriptor_;
1653 }
1654
1655 const PrimitiveGroup& PrimitiveGroup::default_instance() {
1656   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
1657 }
1658
1659 PrimitiveGroup* PrimitiveGroup::default_instance_ = NULL;
1660
1661 PrimitiveGroup* PrimitiveGroup::New() const {
1662   return new PrimitiveGroup;
1663 }
1664
1665 void PrimitiveGroup::Clear() {
1666   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
1667     if (_has_bit(1)) {
1668       if (dense_ != NULL) dense_->::PBF::DenseNodes::Clear();
1669     }
1670   }
1671   nodes_.Clear();
1672   ways_.Clear();
1673   relations_.Clear();
1674   changesets_.Clear();
1675   ::memset(_has_bits_, 0, sizeof(_has_bits_));
1676   mutable_unknown_fields()->Clear();
1677 }
1678
1679 bool PrimitiveGroup::MergePartialFromCodedStream(
1680     ::google::protobuf::io::CodedInputStream* input) {
1681 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1682   ::google::protobuf::uint32 tag;
1683   while ((tag = input->ReadTag()) != 0) {
1684     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1685       // repeated .PBF.Node nodes = 1;
1686       case 1: {
1687         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1688             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1689          parse_nodes:
1690           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1691                 input, add_nodes()));
1692         } else {
1693           goto handle_uninterpreted;
1694         }
1695         if (input->ExpectTag(10)) goto parse_nodes;
1696         if (input->ExpectTag(18)) goto parse_dense;
1697         break;
1698       }
1699       
1700       // optional .PBF.DenseNodes dense = 2;
1701       case 2: {
1702         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1703             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1704          parse_dense:
1705           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1706                input, mutable_dense()));
1707         } else {
1708           goto handle_uninterpreted;
1709         }
1710         if (input->ExpectTag(26)) goto parse_ways;
1711         break;
1712       }
1713       
1714       // repeated .PBF.Way ways = 3;
1715       case 3: {
1716         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1717             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1718          parse_ways:
1719           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1720                 input, add_ways()));
1721         } else {
1722           goto handle_uninterpreted;
1723         }
1724         if (input->ExpectTag(26)) goto parse_ways;
1725         if (input->ExpectTag(34)) goto parse_relations;
1726         break;
1727       }
1728       
1729       // repeated .PBF.Relation relations = 4;
1730       case 4: {
1731         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1732             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1733          parse_relations:
1734           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1735                 input, add_relations()));
1736         } else {
1737           goto handle_uninterpreted;
1738         }
1739         if (input->ExpectTag(34)) goto parse_relations;
1740         if (input->ExpectTag(42)) goto parse_changesets;
1741         break;
1742       }
1743       
1744       // repeated .PBF.ChangeSet changesets = 5;
1745       case 5: {
1746         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1747             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1748          parse_changesets:
1749           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1750                 input, add_changesets()));
1751         } else {
1752           goto handle_uninterpreted;
1753         }
1754         if (input->ExpectTag(42)) goto parse_changesets;
1755         if (input->ExpectAtEnd()) return true;
1756         break;
1757       }
1758       
1759       default: {
1760       handle_uninterpreted:
1761         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1762             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1763           return true;
1764         }
1765         DO_(::google::protobuf::internal::WireFormat::SkipField(
1766               input, tag, mutable_unknown_fields()));
1767         break;
1768       }
1769     }
1770   }
1771   return true;
1772 #undef DO_
1773 }
1774
1775 void PrimitiveGroup::SerializeWithCachedSizes(
1776     ::google::protobuf::io::CodedOutputStream* output) const {
1777   // repeated .PBF.Node nodes = 1;
1778   for (int i = 0; i < this->nodes_size(); i++) {
1779     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1780       1, this->nodes(i), output);
1781   }
1782   
1783   // optional .PBF.DenseNodes dense = 2;
1784   if (_has_bit(1)) {
1785     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1786       2, this->dense(), output);
1787   }
1788   
1789   // repeated .PBF.Way ways = 3;
1790   for (int i = 0; i < this->ways_size(); i++) {
1791     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1792       3, this->ways(i), output);
1793   }
1794   
1795   // repeated .PBF.Relation relations = 4;
1796   for (int i = 0; i < this->relations_size(); i++) {
1797     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1798       4, this->relations(i), output);
1799   }
1800   
1801   // repeated .PBF.ChangeSet changesets = 5;
1802   for (int i = 0; i < this->changesets_size(); i++) {
1803     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
1804       5, this->changesets(i), output);
1805   }
1806   
1807   if (!unknown_fields().empty()) {
1808     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1809         unknown_fields(), output);
1810   }
1811 }
1812
1813 ::google::protobuf::uint8* PrimitiveGroup::SerializeWithCachedSizesToArray(
1814     ::google::protobuf::uint8* target) const {
1815   // repeated .PBF.Node nodes = 1;
1816   for (int i = 0; i < this->nodes_size(); i++) {
1817     target = ::google::protobuf::internal::WireFormatLite::
1818       WriteMessageNoVirtualToArray(
1819         1, this->nodes(i), target);
1820   }
1821   
1822   // optional .PBF.DenseNodes dense = 2;
1823   if (_has_bit(1)) {
1824     target = ::google::protobuf::internal::WireFormatLite::
1825       WriteMessageNoVirtualToArray(
1826         2, this->dense(), target);
1827   }
1828   
1829   // repeated .PBF.Way ways = 3;
1830   for (int i = 0; i < this->ways_size(); i++) {
1831     target = ::google::protobuf::internal::WireFormatLite::
1832       WriteMessageNoVirtualToArray(
1833         3, this->ways(i), target);
1834   }
1835   
1836   // repeated .PBF.Relation relations = 4;
1837   for (int i = 0; i < this->relations_size(); i++) {
1838     target = ::google::protobuf::internal::WireFormatLite::
1839       WriteMessageNoVirtualToArray(
1840         4, this->relations(i), target);
1841   }
1842   
1843   // repeated .PBF.ChangeSet changesets = 5;
1844   for (int i = 0; i < this->changesets_size(); i++) {
1845     target = ::google::protobuf::internal::WireFormatLite::
1846       WriteMessageNoVirtualToArray(
1847         5, this->changesets(i), target);
1848   }
1849   
1850   if (!unknown_fields().empty()) {
1851     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1852         unknown_fields(), target);
1853   }
1854   return target;
1855 }
1856
1857 int PrimitiveGroup::ByteSize() const {
1858   int total_size = 0;
1859   
1860   if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
1861     // optional .PBF.DenseNodes dense = 2;
1862     if (has_dense()) {
1863       total_size += 1 +
1864         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1865           this->dense());
1866     }
1867     
1868   }
1869   // repeated .PBF.Node nodes = 1;
1870   total_size += 1 * this->nodes_size();
1871   for (int i = 0; i < this->nodes_size(); i++) {
1872     total_size +=
1873       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1874         this->nodes(i));
1875   }
1876   
1877   // repeated .PBF.Way ways = 3;
1878   total_size += 1 * this->ways_size();
1879   for (int i = 0; i < this->ways_size(); i++) {
1880     total_size +=
1881       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1882         this->ways(i));
1883   }
1884   
1885   // repeated .PBF.Relation relations = 4;
1886   total_size += 1 * this->relations_size();
1887   for (int i = 0; i < this->relations_size(); i++) {
1888     total_size +=
1889       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1890         this->relations(i));
1891   }
1892   
1893   // repeated .PBF.ChangeSet changesets = 5;
1894   total_size += 1 * this->changesets_size();
1895   for (int i = 0; i < this->changesets_size(); i++) {
1896     total_size +=
1897       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1898         this->changesets(i));
1899   }
1900   
1901   if (!unknown_fields().empty()) {
1902     total_size +=
1903       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1904         unknown_fields());
1905   }
1906   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
1907   _cached_size_ = total_size;
1908   GOOGLE_SAFE_CONCURRENT_WRITES_END();
1909   return total_size;
1910 }
1911
1912 void PrimitiveGroup::MergeFrom(const ::google::protobuf::Message& from) {
1913   GOOGLE_CHECK_NE(&from, this);
1914   const PrimitiveGroup* source =
1915     ::google::protobuf::internal::dynamic_cast_if_available<const PrimitiveGroup*>(
1916       &from);
1917   if (source == NULL) {
1918     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1919   } else {
1920     MergeFrom(*source);
1921   }
1922 }
1923
1924 void PrimitiveGroup::MergeFrom(const PrimitiveGroup& from) {
1925   GOOGLE_CHECK_NE(&from, this);
1926   nodes_.MergeFrom(from.nodes_);
1927   ways_.MergeFrom(from.ways_);
1928   relations_.MergeFrom(from.relations_);
1929   changesets_.MergeFrom(from.changesets_);
1930   if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
1931     if (from._has_bit(1)) {
1932       mutable_dense()->::PBF::DenseNodes::MergeFrom(from.dense());
1933     }
1934   }
1935   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1936 }
1937
1938 void PrimitiveGroup::CopyFrom(const ::google::protobuf::Message& from) {
1939   if (&from == this) return;
1940   Clear();
1941   MergeFrom(from);
1942 }
1943
1944 void PrimitiveGroup::CopyFrom(const PrimitiveGroup& from) {
1945   if (&from == this) return;
1946   Clear();
1947   MergeFrom(from);
1948 }
1949
1950 bool PrimitiveGroup::IsInitialized() const {
1951   
1952   for (int i = 0; i < nodes_size(); i++) {
1953     if (!this->nodes(i).IsInitialized()) return false;
1954   }
1955   for (int i = 0; i < ways_size(); i++) {
1956     if (!this->ways(i).IsInitialized()) return false;
1957   }
1958   for (int i = 0; i < relations_size(); i++) {
1959     if (!this->relations(i).IsInitialized()) return false;
1960   }
1961   for (int i = 0; i < changesets_size(); i++) {
1962     if (!this->changesets(i).IsInitialized()) return false;
1963   }
1964   return true;
1965 }
1966
1967 void PrimitiveGroup::Swap(PrimitiveGroup* other) {
1968   if (other != this) {
1969     nodes_.Swap(&other->nodes_);
1970     std::swap(dense_, other->dense_);
1971     ways_.Swap(&other->ways_);
1972     relations_.Swap(&other->relations_);
1973     changesets_.Swap(&other->changesets_);
1974     std::swap(_has_bits_[0], other->_has_bits_[0]);
1975     _unknown_fields_.Swap(&other->_unknown_fields_);
1976     std::swap(_cached_size_, other->_cached_size_);
1977   }
1978 }
1979
1980 ::google::protobuf::Metadata PrimitiveGroup::GetMetadata() const {
1981   protobuf_AssignDescriptorsOnce();
1982   ::google::protobuf::Metadata metadata;
1983   metadata.descriptor = PrimitiveGroup_descriptor_;
1984   metadata.reflection = PrimitiveGroup_reflection_;
1985   return metadata;
1986 }
1987
1988
1989 // ===================================================================
1990
1991 #ifndef _MSC_VER
1992 const int StringTable::kSFieldNumber;
1993 #endif  // !_MSC_VER
1994
1995 StringTable::StringTable()
1996   : ::google::protobuf::Message() {
1997   SharedCtor();
1998 }
1999
2000 void StringTable::InitAsDefaultInstance() {
2001 }
2002
2003 StringTable::StringTable(const StringTable& from)
2004   : ::google::protobuf::Message() {
2005   SharedCtor();
2006   MergeFrom(from);
2007 }
2008
2009 void StringTable::SharedCtor() {
2010   _cached_size_ = 0;
2011   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2012 }
2013
2014 StringTable::~StringTable() {
2015   SharedDtor();
2016 }
2017
2018 void StringTable::SharedDtor() {
2019   if (this != default_instance_) {
2020   }
2021 }
2022
2023 void StringTable::SetCachedSize(int size) const {
2024   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2025   _cached_size_ = size;
2026   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2027 }
2028 const ::google::protobuf::Descriptor* StringTable::descriptor() {
2029   protobuf_AssignDescriptorsOnce();
2030   return StringTable_descriptor_;
2031 }
2032
2033 const StringTable& StringTable::default_instance() {
2034   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
2035 }
2036
2037 StringTable* StringTable::default_instance_ = NULL;
2038
2039 StringTable* StringTable::New() const {
2040   return new StringTable;
2041 }
2042
2043 void StringTable::Clear() {
2044   s_.Clear();
2045   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2046   mutable_unknown_fields()->Clear();
2047 }
2048
2049 bool StringTable::MergePartialFromCodedStream(
2050     ::google::protobuf::io::CodedInputStream* input) {
2051 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2052   ::google::protobuf::uint32 tag;
2053   while ((tag = input->ReadTag()) != 0) {
2054     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2055       // repeated bytes s = 1;
2056       case 1: {
2057         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2058             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2059          parse_s:
2060           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
2061                 input, this->add_s()));
2062         } else {
2063           goto handle_uninterpreted;
2064         }
2065         if (input->ExpectTag(10)) goto parse_s;
2066         if (input->ExpectAtEnd()) return true;
2067         break;
2068       }
2069       
2070       default: {
2071       handle_uninterpreted:
2072         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2073             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2074           return true;
2075         }
2076         DO_(::google::protobuf::internal::WireFormat::SkipField(
2077               input, tag, mutable_unknown_fields()));
2078         break;
2079       }
2080     }
2081   }
2082   return true;
2083 #undef DO_
2084 }
2085
2086 void StringTable::SerializeWithCachedSizes(
2087     ::google::protobuf::io::CodedOutputStream* output) const {
2088   // repeated bytes s = 1;
2089   for (int i = 0; i < this->s_size(); i++) {
2090     ::google::protobuf::internal::WireFormatLite::WriteBytes(
2091       1, this->s(i), output);
2092   }
2093   
2094   if (!unknown_fields().empty()) {
2095     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2096         unknown_fields(), output);
2097   }
2098 }
2099
2100 ::google::protobuf::uint8* StringTable::SerializeWithCachedSizesToArray(
2101     ::google::protobuf::uint8* target) const {
2102   // repeated bytes s = 1;
2103   for (int i = 0; i < this->s_size(); i++) {
2104     target = ::google::protobuf::internal::WireFormatLite::
2105       WriteBytesToArray(1, this->s(i), target);
2106   }
2107   
2108   if (!unknown_fields().empty()) {
2109     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2110         unknown_fields(), target);
2111   }
2112   return target;
2113 }
2114
2115 int StringTable::ByteSize() const {
2116   int total_size = 0;
2117   
2118   // repeated bytes s = 1;
2119   total_size += 1 * this->s_size();
2120   for (int i = 0; i < this->s_size(); i++) {
2121     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
2122       this->s(i));
2123   }
2124   
2125   if (!unknown_fields().empty()) {
2126     total_size +=
2127       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2128         unknown_fields());
2129   }
2130   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2131   _cached_size_ = total_size;
2132   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2133   return total_size;
2134 }
2135
2136 void StringTable::MergeFrom(const ::google::protobuf::Message& from) {
2137   GOOGLE_CHECK_NE(&from, this);
2138   const StringTable* source =
2139     ::google::protobuf::internal::dynamic_cast_if_available<const StringTable*>(
2140       &from);
2141   if (source == NULL) {
2142     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2143   } else {
2144     MergeFrom(*source);
2145   }
2146 }
2147
2148 void StringTable::MergeFrom(const StringTable& from) {
2149   GOOGLE_CHECK_NE(&from, this);
2150   s_.MergeFrom(from.s_);
2151   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2152 }
2153
2154 void StringTable::CopyFrom(const ::google::protobuf::Message& from) {
2155   if (&from == this) return;
2156   Clear();
2157   MergeFrom(from);
2158 }
2159
2160 void StringTable::CopyFrom(const StringTable& from) {
2161   if (&from == this) return;
2162   Clear();
2163   MergeFrom(from);
2164 }
2165
2166 bool StringTable::IsInitialized() const {
2167   
2168   return true;
2169 }
2170
2171 void StringTable::Swap(StringTable* other) {
2172   if (other != this) {
2173     s_.Swap(&other->s_);
2174     std::swap(_has_bits_[0], other->_has_bits_[0]);
2175     _unknown_fields_.Swap(&other->_unknown_fields_);
2176     std::swap(_cached_size_, other->_cached_size_);
2177   }
2178 }
2179
2180 ::google::protobuf::Metadata StringTable::GetMetadata() const {
2181   protobuf_AssignDescriptorsOnce();
2182   ::google::protobuf::Metadata metadata;
2183   metadata.descriptor = StringTable_descriptor_;
2184   metadata.reflection = StringTable_reflection_;
2185   return metadata;
2186 }
2187
2188
2189 // ===================================================================
2190
2191 #ifndef _MSC_VER
2192 const int Info::kVersionFieldNumber;
2193 const int Info::kTimestampFieldNumber;
2194 const int Info::kChangesetFieldNumber;
2195 const int Info::kUidFieldNumber;
2196 const int Info::kUserSidFieldNumber;
2197 #endif  // !_MSC_VER
2198
2199 Info::Info()
2200   : ::google::protobuf::Message() {
2201   SharedCtor();
2202 }
2203
2204 void Info::InitAsDefaultInstance() {
2205 }
2206
2207 Info::Info(const Info& from)
2208   : ::google::protobuf::Message() {
2209   SharedCtor();
2210   MergeFrom(from);
2211 }
2212
2213 void Info::SharedCtor() {
2214   _cached_size_ = 0;
2215   version_ = -1;
2216   timestamp_ = GOOGLE_LONGLONG(0);
2217   changeset_ = GOOGLE_LONGLONG(0);
2218   uid_ = 0;
2219   user_sid_ = 0;
2220   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2221 }
2222
2223 Info::~Info() {
2224   SharedDtor();
2225 }
2226
2227 void Info::SharedDtor() {
2228   if (this != default_instance_) {
2229   }
2230 }
2231
2232 void Info::SetCachedSize(int size) const {
2233   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2234   _cached_size_ = size;
2235   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2236 }
2237 const ::google::protobuf::Descriptor* Info::descriptor() {
2238   protobuf_AssignDescriptorsOnce();
2239   return Info_descriptor_;
2240 }
2241
2242 const Info& Info::default_instance() {
2243   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
2244 }
2245
2246 Info* Info::default_instance_ = NULL;
2247
2248 Info* Info::New() const {
2249   return new Info;
2250 }
2251
2252 void Info::Clear() {
2253   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2254     version_ = -1;
2255     timestamp_ = GOOGLE_LONGLONG(0);
2256     changeset_ = GOOGLE_LONGLONG(0);
2257     uid_ = 0;
2258     user_sid_ = 0;
2259   }
2260   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2261   mutable_unknown_fields()->Clear();
2262 }
2263
2264 bool Info::MergePartialFromCodedStream(
2265     ::google::protobuf::io::CodedInputStream* input) {
2266 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2267   ::google::protobuf::uint32 tag;
2268   while ((tag = input->ReadTag()) != 0) {
2269     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2270       // optional int32 version = 1 [default = -1];
2271       case 1: {
2272         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2273             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2274           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2275                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2276                  input, &version_)));
2277           _set_bit(0);
2278         } else {
2279           goto handle_uninterpreted;
2280         }
2281         if (input->ExpectTag(16)) goto parse_timestamp;
2282         break;
2283       }
2284       
2285       // optional int64 timestamp = 2;
2286       case 2: {
2287         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2288             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2289          parse_timestamp:
2290           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2291                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
2292                  input, &timestamp_)));
2293           _set_bit(1);
2294         } else {
2295           goto handle_uninterpreted;
2296         }
2297         if (input->ExpectTag(24)) goto parse_changeset;
2298         break;
2299       }
2300       
2301       // optional int64 changeset = 3;
2302       case 3: {
2303         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2304             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2305          parse_changeset:
2306           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2307                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
2308                  input, &changeset_)));
2309           _set_bit(2);
2310         } else {
2311           goto handle_uninterpreted;
2312         }
2313         if (input->ExpectTag(32)) goto parse_uid;
2314         break;
2315       }
2316       
2317       // optional int32 uid = 4;
2318       case 4: {
2319         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2320             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2321          parse_uid:
2322           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2323                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2324                  input, &uid_)));
2325           _set_bit(3);
2326         } else {
2327           goto handle_uninterpreted;
2328         }
2329         if (input->ExpectTag(40)) goto parse_user_sid;
2330         break;
2331       }
2332       
2333       // optional int32 user_sid = 5;
2334       case 5: {
2335         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2336             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2337          parse_user_sid:
2338           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
2339                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2340                  input, &user_sid_)));
2341           _set_bit(4);
2342         } else {
2343           goto handle_uninterpreted;
2344         }
2345         if (input->ExpectAtEnd()) return true;
2346         break;
2347       }
2348       
2349       default: {
2350       handle_uninterpreted:
2351         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2352             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2353           return true;
2354         }
2355         DO_(::google::protobuf::internal::WireFormat::SkipField(
2356               input, tag, mutable_unknown_fields()));
2357         break;
2358       }
2359     }
2360   }
2361   return true;
2362 #undef DO_
2363 }
2364
2365 void Info::SerializeWithCachedSizes(
2366     ::google::protobuf::io::CodedOutputStream* output) const {
2367   // optional int32 version = 1 [default = -1];
2368   if (_has_bit(0)) {
2369     ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->version(), output);
2370   }
2371   
2372   // optional int64 timestamp = 2;
2373   if (_has_bit(1)) {
2374     ::google::protobuf::internal::WireFormatLite::WriteInt64(2, this->timestamp(), output);
2375   }
2376   
2377   // optional int64 changeset = 3;
2378   if (_has_bit(2)) {
2379     ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->changeset(), output);
2380   }
2381   
2382   // optional int32 uid = 4;
2383   if (_has_bit(3)) {
2384     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->uid(), output);
2385   }
2386   
2387   // optional int32 user_sid = 5;
2388   if (_has_bit(4)) {
2389     ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->user_sid(), output);
2390   }
2391   
2392   if (!unknown_fields().empty()) {
2393     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2394         unknown_fields(), output);
2395   }
2396 }
2397
2398 ::google::protobuf::uint8* Info::SerializeWithCachedSizesToArray(
2399     ::google::protobuf::uint8* target) const {
2400   // optional int32 version = 1 [default = -1];
2401   if (_has_bit(0)) {
2402     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->version(), target);
2403   }
2404   
2405   // optional int64 timestamp = 2;
2406   if (_has_bit(1)) {
2407     target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(2, this->timestamp(), target);
2408   }
2409   
2410   // optional int64 changeset = 3;
2411   if (_has_bit(2)) {
2412     target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->changeset(), target);
2413   }
2414   
2415   // optional int32 uid = 4;
2416   if (_has_bit(3)) {
2417     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->uid(), target);
2418   }
2419   
2420   // optional int32 user_sid = 5;
2421   if (_has_bit(4)) {
2422     target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->user_sid(), target);
2423   }
2424   
2425   if (!unknown_fields().empty()) {
2426     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2427         unknown_fields(), target);
2428   }
2429   return target;
2430 }
2431
2432 int Info::ByteSize() const {
2433   int total_size = 0;
2434   
2435   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2436     // optional int32 version = 1 [default = -1];
2437     if (has_version()) {
2438       total_size += 1 +
2439         ::google::protobuf::internal::WireFormatLite::Int32Size(
2440           this->version());
2441     }
2442     
2443     // optional int64 timestamp = 2;
2444     if (has_timestamp()) {
2445       total_size += 1 +
2446         ::google::protobuf::internal::WireFormatLite::Int64Size(
2447           this->timestamp());
2448     }
2449     
2450     // optional int64 changeset = 3;
2451     if (has_changeset()) {
2452       total_size += 1 +
2453         ::google::protobuf::internal::WireFormatLite::Int64Size(
2454           this->changeset());
2455     }
2456     
2457     // optional int32 uid = 4;
2458     if (has_uid()) {
2459       total_size += 1 +
2460         ::google::protobuf::internal::WireFormatLite::Int32Size(
2461           this->uid());
2462     }
2463     
2464     // optional int32 user_sid = 5;
2465     if (has_user_sid()) {
2466       total_size += 1 +
2467         ::google::protobuf::internal::WireFormatLite::Int32Size(
2468           this->user_sid());
2469     }
2470     
2471   }
2472   if (!unknown_fields().empty()) {
2473     total_size +=
2474       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2475         unknown_fields());
2476   }
2477   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2478   _cached_size_ = total_size;
2479   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2480   return total_size;
2481 }
2482
2483 void Info::MergeFrom(const ::google::protobuf::Message& from) {
2484   GOOGLE_CHECK_NE(&from, this);
2485   const Info* source =
2486     ::google::protobuf::internal::dynamic_cast_if_available<const Info*>(
2487       &from);
2488   if (source == NULL) {
2489     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2490   } else {
2491     MergeFrom(*source);
2492   }
2493 }
2494
2495 void Info::MergeFrom(const Info& from) {
2496   GOOGLE_CHECK_NE(&from, this);
2497   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2498     if (from._has_bit(0)) {
2499       set_version(from.version());
2500     }
2501     if (from._has_bit(1)) {
2502       set_timestamp(from.timestamp());
2503     }
2504     if (from._has_bit(2)) {
2505       set_changeset(from.changeset());
2506     }
2507     if (from._has_bit(3)) {
2508       set_uid(from.uid());
2509     }
2510     if (from._has_bit(4)) {
2511       set_user_sid(from.user_sid());
2512     }
2513   }
2514   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2515 }
2516
2517 void Info::CopyFrom(const ::google::protobuf::Message& from) {
2518   if (&from == this) return;
2519   Clear();
2520   MergeFrom(from);
2521 }
2522
2523 void Info::CopyFrom(const Info& from) {
2524   if (&from == this) return;
2525   Clear();
2526   MergeFrom(from);
2527 }
2528
2529 bool Info::IsInitialized() const {
2530   
2531   return true;
2532 }
2533
2534 void Info::Swap(Info* other) {
2535   if (other != this) {
2536     std::swap(version_, other->version_);
2537     std::swap(timestamp_, other->timestamp_);
2538     std::swap(changeset_, other->changeset_);
2539     std::swap(uid_, other->uid_);
2540     std::swap(user_sid_, other->user_sid_);
2541     std::swap(_has_bits_[0], other->_has_bits_[0]);
2542     _unknown_fields_.Swap(&other->_unknown_fields_);
2543     std::swap(_cached_size_, other->_cached_size_);
2544   }
2545 }
2546
2547 ::google::protobuf::Metadata Info::GetMetadata() const {
2548   protobuf_AssignDescriptorsOnce();
2549   ::google::protobuf::Metadata metadata;
2550   metadata.descriptor = Info_descriptor_;
2551   metadata.reflection = Info_reflection_;
2552   return metadata;
2553 }
2554
2555
2556 // ===================================================================
2557
2558 #ifndef _MSC_VER
2559 const int DenseInfo::kVersionFieldNumber;
2560 const int DenseInfo::kTimestampFieldNumber;
2561 const int DenseInfo::kChangesetFieldNumber;
2562 const int DenseInfo::kUidFieldNumber;
2563 const int DenseInfo::kUserSidFieldNumber;
2564 #endif  // !_MSC_VER
2565
2566 DenseInfo::DenseInfo()
2567   : ::google::protobuf::Message() {
2568   SharedCtor();
2569 }
2570
2571 void DenseInfo::InitAsDefaultInstance() {
2572 }
2573
2574 DenseInfo::DenseInfo(const DenseInfo& from)
2575   : ::google::protobuf::Message() {
2576   SharedCtor();
2577   MergeFrom(from);
2578 }
2579
2580 void DenseInfo::SharedCtor() {
2581   _cached_size_ = 0;
2582   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2583 }
2584
2585 DenseInfo::~DenseInfo() {
2586   SharedDtor();
2587 }
2588
2589 void DenseInfo::SharedDtor() {
2590   if (this != default_instance_) {
2591   }
2592 }
2593
2594 void DenseInfo::SetCachedSize(int size) const {
2595   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
2596   _cached_size_ = size;
2597   GOOGLE_SAFE_CONCURRENT_WRITES_END();
2598 }
2599 const ::google::protobuf::Descriptor* DenseInfo::descriptor() {
2600   protobuf_AssignDescriptorsOnce();
2601   return DenseInfo_descriptor_;
2602 }
2603
2604 const DenseInfo& DenseInfo::default_instance() {
2605   if (default_instance_ == NULL) protobuf_AddDesc_osmformat_2eproto();  return *default_instance_;
2606 }
2607
2608 DenseInfo* DenseInfo::default_instance_ = NULL;
2609
2610 DenseInfo* DenseInfo::New() const {
2611   return new DenseInfo;
2612 }
2613
2614 void DenseInfo::Clear() {
2615   version_.Clear();
2616   timestamp_.Clear();
2617   changeset_.Clear();
2618   uid_.Clear();
2619   user_sid_.Clear();
2620   ::memset(_has_bits_, 0, sizeof(_has_bits_));
2621   mutable_unknown_fields()->Clear();
2622 }
2623
2624 bool DenseInfo::MergePartialFromCodedStream(
2625     ::google::protobuf::io::CodedInputStream* input) {
2626 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2627   ::google::protobuf::uint32 tag;
2628   while ((tag = input->ReadTag()) != 0) {
2629     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2630       // repeated int32 version = 1 [packed = true];
2631       case 1: {
2632         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2633             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2634           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
2635                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2636                  input, this->mutable_version())));
2637         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
2638                    == ::google::protobuf::internal::WireFormatLite::
2639                       WIRETYPE_VARINT) {
2640           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
2641                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
2642                  1, 10, input, this->mutable_version())));
2643         } else {
2644           goto handle_uninterpreted;
2645         }
2646         if (input->ExpectTag(18)) goto parse_timestamp;
2647         break;
2648       }
2649       
2650       // repeated sint64 timestamp = 2 [packed = true];
2651       case 2: {
2652         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2653             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2654          parse_timestamp:
2655           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
2656                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
2657                  input, this->mutable_timestamp())));
2658         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
2659                    == ::google::protobuf::internal::WireFormatLite::
2660                       WIRETYPE_VARINT) {
2661           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
2662                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
2663                  1, 18, input, this->mutable_timestamp())));
2664         } else {
2665           goto handle_uninterpreted;
2666         }
2667         if (input->ExpectTag(26)) goto parse_changeset;
2668         break;
2669       }
2670       
2671       // repeated sint64 changeset = 3 [packed = true];
2672       case 3: {
2673         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2674             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2675          parse_changeset:
2676           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
2677                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
2678                  input, this->mutable_changeset())));
2679         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
2680                    == ::google::protobuf::internal::WireFormatLite::
2681                       WIRETYPE_VARINT) {
2682           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
2683                    ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_SINT64>(
2684                  1, 26, input, this->mutable_changeset())));
2685         } else {
2686           goto handle_uninterpreted;
2687         }
2688         if (input->ExpectTag(34)) goto parse_uid;
2689         break;
2690       }
2691       
2692       // repeated sint32 uid = 4 [packed = true];
2693       case 4: {
2694         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2695             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2696          parse_uid:
2697           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
2698                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
2699                  input, this->mutable_uid())));
2700         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
2701                    == ::google::protobuf::internal::WireFormatLite::
2702                       WIRETYPE_VARINT) {
2703           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
2704                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
2705                  1, 34, input, this->mutable_uid())));
2706         } else {
2707           goto handle_uninterpreted;
2708         }
2709         if (input->ExpectTag(42)) goto parse_user_sid;
2710         break;
2711       }
2712       
2713       // repeated sint32 user_sid = 5 [packed = true];
2714       case 5: {
2715         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2716             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2717          parse_user_sid:
2718           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
2719                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
2720                  input, this->mutable_user_sid())));
2721         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
2722                    == ::google::protobuf::internal::WireFormatLite::
2723                       WIRETYPE_VARINT) {
2724           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
2725                    ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_SINT32>(
2726                  1, 42, input, this->mutable_user_sid())));
2727         } else {
2728           goto handle_uninterpreted;
2729         }
2730         if (input->ExpectAtEnd()) return true;
2731         break;
2732       }
2733       
2734       default: {
2735       handle_uninterpreted:
2736         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2737             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2738           return true;
2739         }
2740         DO_(::google::protobuf::internal::WireFormat::SkipField(
2741               input, tag, mutable_unknown_fields()));
2742         break;
2743       }
2744     }
2745   }
2746   return true;
2747 #undef DO_
2748 }
2749
2750 void DenseInfo::SerializeWithCachedSizes(
2751     ::google::protobuf::io::CodedOutputStream* output) const {
2752   // repeated int32 version = 1 [packed = true];
2753   if (this->version_size() > 0) {
2754     ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
2755     output->WriteVarint32(_version_cached_byte_size_);
2756   }
2757   for (int i = 0; i < this->version_size(); i++) {
2758     ::google::protobuf::internal::WireFormatLite::WriteInt32NoTag(
2759       this->version(i), output);
2760   }
2761   
2762   // repeated sint64 timestamp = 2 [packed = true];
2763   if (this->timestamp_size() > 0) {
2764     ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
2765     output->WriteVarint32(_timestamp_cached_byte_size_);
2766   }
2767   for (int i = 0; i < this->timestamp_size(); i++) {
2768     ::google::protobuf::internal::WireFormatLite::WriteSInt64NoTag(
2769       this->timestamp(i), output);
2770   }
2771   
2772   // repeated sint64 changeset = 3 [packed = true];
2773   if (this->changeset_size() > 0) {
2774     ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
2775     output->WriteVarint32(_changeset_cached_byte_size_);
2776   }
2777   for (int i = 0; i < this->changeset_size(); i++) {
2778     ::google::protobuf::internal::WireFormatLite::WriteSInt64NoTag(
2779       this->changeset(i), output);
2780   }
2781   
2782   // repeated sint32 uid = 4 [packed = true];
2783   if (this->uid_size() > 0) {
2784     ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
2785     output->WriteVarint32(_uid_cached_byte_size_);
2786   }
2787   for (int i = 0; i < this->uid_size(); i++) {
2788     ::google::protobuf::internal::WireFormatLite::WriteSInt32NoTag(
2789       this->uid(i), output);
2790   }
2791   
2792   // repeated sint32 user_sid = 5 [packed = true];
2793   if (this->user_sid_size() > 0) {
2794     ::google::protobuf::internal::WireFormatLite::WriteTag(5, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
2795     output->WriteVarint32(_user_sid_cached_byte_size_);
2796   }
2797   for (int i = 0; i < this->user_sid_size(); i++) {
2798     ::google::protobuf::internal::WireFormatLite::WriteSInt32NoTag(
2799       this->user_sid(i), output);
2800   }
2801   
2802   if (!unknown_fields().empty()) {
2803     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2804         unknown_fields(), output);
2805   }
2806 }
2807
2808 ::google::protobuf::uint8* DenseInfo::SerializeWithCachedSizesToArray(
2809     ::google::protobuf::uint8* target) const {
2810   // repeated int32 version = 1 [packed = true];
2811   if (this->version_size() > 0) {
2812     target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
2813       1,