for new protobuf version 2.17.0

.appveyor.yml

       target: x86_64-pc-windows-msvc
     - channel: stable
       target: i686-pc-windows-msvc
-    - channel: 1.36.0
+    - channel: 1.44.1
       target: x86_64-pc-windows-msvc
 
 install:

.travis.yml

   - stable
   - beta
   - nightly
-  - 1.36.0
+  - 1.44.1
 script:
-  - |
-      cargo test --verbose;
-      cargo test --verbose --no-default-features;
-      cargo doc --verbose;
+  - cargo test --verbose
+  - cargo test --verbose --no-default-features
+  - cargo doc --verbose
 env:
   - RUSTFLAGS="-D warnings"

Cargo.toml

 [package]
 name = "osmpbf"
-version = "0.1.17"
+version = "0.2.2"
 authors = ["Johannes Hofmann <mail@b-r-u.org>"]
 readme = "README.md"
 repository = "https://github.com/b-r-u/osmpbf"
 system-libz = ["flate2"]
 
 [dependencies]
-protobuf = "=2.10.1"
+protobuf = "2.14"
 byteorder = "1.1"
 flate2 = { version = "1.0", optional = true }
 inflate = "0.4"

README.md

 
 ```toml
 [dependencies]
-osmpbf = "0.1"
+osmpbf = "0.2"
 ```
 
 and if you're using Rust 2015, add this line to the crate root:
 Here's a simple example that counts all the ways in a file:
 
 ```rust
-extern crate osmpbf;
-
-use osmpbf::*;
+use osmpbf::{ElementReader, Element};
 
-fn main() {
-    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
-    let mut ways = 0_u64;
+let reader = ElementReader::from_path("tests/test.osm.pbf")?;
+let mut ways = 0_u64;
 
-    // Increment the counter by one for each way.
-    reader.for_each(|element| {
-        if let Element::Way(_) = element {
-            ways += 1;
-        }
-    }).unwrap();
+// Increment the counter by one for each way.
+reader.for_each(|element| {
+    if let Element::Way(_) = element {
+        ways += 1;
+    }
+})?;
 
-    println!("Number of ways: {}", ways);
-}
+println!("Number of ways: {}", ways);
 ```
 
 In this second example, we also count the ways but make use of all cores by
 decoding the file in parallel:
 
 ```rust
-use osmpbf::*;
-
-fn main() {
-    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
-
-    // Count the ways
-    let ways = reader.par_map_reduce(
-        |element| {
-            match element {
-                Element::Way(_) => 1,
-                _ => 0,
-            }
-        },
-        || 0_u64,      // Zero is the identity value for addition
-        |a, b| a + b   // Sum the partial results
-    ).unwrap();
-
-    println!("Number of ways: {}", ways);
-}
+use osmpbf::{ElementReader, Element};
+
+let reader = ElementReader::from_path("tests/test.osm.pbf")?;
+
+// Count the ways
+let ways = reader.par_map_reduce(
+    |element| {
+        match element {
+            Element::Way(_) => 1,
+            _ => 0,
+        }
+    },
+    || 0_u64,      // Zero is the identity value for addition
+    |a, b| a + b   // Sum the partial results
+)?;
+
+println!("Number of ways: {}", ways);
 ```
 
 ## The PBF format

build_proto.rs

         println!("cargo:rerun-if-changed={}", path);
     }
 
-    protoc_rust::run(protoc_rust::Args {
-        out_dir: "src/proto",
-        input: &proto_files,
-        customize: protoc_rust::Customize {
-            ..Default::default()
-        },
-        includes: &[],
-    }).expect("protoc");
+    protoc_rust::Codegen::new()
+        .out_dir("src/proto")
+        .inputs(&proto_files)
+        .run()
+        .expect("Running protoc failed.");
 }

src/dense.rs

     /// The node id. It should be unique between nodes and might be negative to indicate
     /// that the element has not yet been uploaded to a server.
     pub id: i64,
-    /// The version of this element.
-    pub version: i32,
-    timestamp: i64,
-    /// The changeset id.
-    pub changeset: i64,
-    /// The user id.
-    pub uid: i32,
-    user_sid: i32,
     lat: i64,
     lon: i64,
     keys_vals_indices: &'a [i32],
+    info: Option<DenseNodeInfo<'a>>,
 }
 
 impl<'a> DenseNode<'a> {
-    /// Returns the user name.
-    pub fn user(&self) -> Result<&'a str> {
-        str_from_stringtable(self.block, self.user_sid as usize)
+    /// return optional metadata about the ndode
+    pub fn info(&'a self) -> Option<&'a DenseNodeInfo<'a>> {
+        self.info.as_ref()
     }
 
     /// Returns the latitude coordinate in degrees.
         (self.nano_lon() / 100) as i32
     }
 
-    /// Returns the time stamp in milliseconds since the epoch.
-    pub fn milli_timestamp(&self) -> i64 {
-        self.timestamp * i64::from(self.block.get_date_granularity())
-    }
-
     /// Returns an iterator over the tags of this node (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Tags)).
     pub fn tags(&self) -> DenseTagIter<'a> {
         DenseTagIter {
 #[derive(Clone, Debug)]
 pub struct DenseNodeIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
-    dids: std::slice::Iter<'a, i64>, // deltas
-    cid: i64,                        // current id
-    versions: std::slice::Iter<'a, i32>,
-    dtimestamps: std::slice::Iter<'a, i64>, // deltas
-    ctimestamp: i64,
-    dchangesets: std::slice::Iter<'a, i64>, // deltas
-    cchangeset: i64,
-    duids: std::slice::Iter<'a, i32>, // deltas
-    cuid: i32,
-    duser_sids: std::slice::Iter<'a, i32>, // deltas
-    cuser_sid: i32,
+    dids: std::slice::Iter<'a, i64>,  // deltas
+    cid: i64,                         // current id
     dlats: std::slice::Iter<'a, i64>, // deltas
     clat: i64,
     dlons: std::slice::Iter<'a, i64>, // deltas
     clon: i64,
     keys_vals_slice: &'a [i32],
     keys_vals_index: usize,
+    info_iter: Option<DenseNodeInfoIter<'a>>,
 }
 
 impl<'a> DenseNodeIter<'a> {
         block: &'a osmformat::PrimitiveBlock,
         osmdense: &'a osmformat::DenseNodes,
     ) -> DenseNodeIter<'a> {
-        let info = osmdense.get_denseinfo();
+        let info_iter = Some(DenseNodeInfoIter::new(block, osmdense.get_denseinfo()));
         DenseNodeIter {
             block,
             dids: osmdense.get_id().iter(),
             cid: 0,
-            versions: info.get_version().iter(),
-            dtimestamps: info.get_timestamp().iter(),
-            ctimestamp: 0,
-            dchangesets: info.get_changeset().iter(),
-            cchangeset: 0,
-            duids: info.get_uid().iter(),
-            cuid: 0,
-            duser_sids: info.get_user_sid().iter(),
-            cuser_sid: 0,
             dlats: osmdense.get_lat().iter(),
             clat: 0,
             dlons: osmdense.get_lon().iter(),
             clon: 0,
             keys_vals_slice: osmdense.get_keys_vals(),
             keys_vals_index: 0,
+            info_iter,
         }
     }
 
             block,
             dids: [].iter(),
             cid: 0,
-            versions: [].iter(),
-            dtimestamps: [].iter(),
-            ctimestamp: 0,
-            dchangesets: [].iter(),
-            cchangeset: 0,
-            duids: [].iter(),
-            cuid: 0,
-            duser_sids: [].iter(),
-            cuser_sid: 0,
             dlats: [].iter(),
             clat: 0,
             dlons: [].iter(),
             clon: 0,
             keys_vals_slice: &[],
             keys_vals_index: 0,
+            info_iter: None,
         }
     }
 }
     fn next(&mut self) -> Option<Self::Item> {
         match (
             self.dids.next(),
-            self.versions.next(),
-            self.dtimestamps.next(),
-            self.dchangesets.next(),
-            self.duids.next(),
-            self.duser_sids.next(),
             self.dlats.next(),
             self.dlons.next(),
+            self.info_iter.as_mut().and_then(|iter| iter.next()),
         ) {
-            (
-                Some(did),
-                Some(version),
-                Some(dtimestamp),
-                Some(dchangeset),
-                Some(duid),
-                Some(duser_sid),
-                Some(dlat),
-                Some(dlon),
-            ) => {
+            (Some(did), Some(dlat), Some(dlon), info) => {
                 self.cid += *did;
-                self.ctimestamp += *dtimestamp;
-                self.cchangeset += *dchangeset;
-                self.cuid += *duid;
-                self.cuser_sid += *duser_sid;
                 self.clat += *dlat;
                 self.clon += *dlon;
 
                 Some(DenseNode {
                     block: self.block,
                     id: self.cid,
-                    version: *version,
-                    timestamp: self.ctimestamp,
-                    changeset: self.cchangeset,
-                    uid: self.cuid,
-                    user_sid: self.cuser_sid,
                     lat: self.clat,
                     lon: self.clon,
                     keys_vals_indices: &self.keys_vals_slice[start_index..end_index],
+                    info,
                 })
             }
             _ => None,
 
 impl<'a> ExactSizeIterator for DenseNodeIter<'a> {}
 
+/// Optional metadata with non-geographic information about a dense node
+#[derive(Clone, Debug)]
+pub struct DenseNodeInfo<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    /// The version of this element.
+    version: i32,
+    /// Timestamp
+    timestamp: i64,
+    /// The changeset id.
+    changeset: i64,
+    /// The user id.
+    uid: i32,
+    // String IDs for usernames.
+    user_sid: i32,
+}
+
+impl<'a> DenseNodeInfo<'a> {
+    /// Returns the version of this element.
+    pub fn version(&self) -> i32 {
+        self.version
+    }
+
+    /// Returns the changeset id.
+    pub fn changeset(&self) -> i64 {
+        self.changeset
+    }
+
+    /// Returns the user id.
+    pub fn uid(&self) -> i32 {
+        self.uid
+    }
+
+    /// Returns the user name.
+    pub fn user(&self) -> Result<&'a str> {
+        str_from_stringtable(self.block, self.user_sid as usize)
+    }
+
+    /// Returns the time stamp in milliseconds since the epoch.
+    pub fn milli_timestamp(&self) -> i64 {
+        self.timestamp * i64::from(self.block.get_date_granularity())
+    }
+}
+
+/// An iterator over dense nodes info. It decodes the delta encoded values.
+#[derive(Clone, Debug)]
+pub struct DenseNodeInfoIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    versions: std::slice::Iter<'a, i32>,
+    dtimestamps: std::slice::Iter<'a, i64>, // deltas
+    ctimestamp: i64,
+    dchangesets: std::slice::Iter<'a, i64>, // deltas
+    cchangeset: i64,
+    duids: std::slice::Iter<'a, i32>, // deltas
+    cuid: i32,
+    duser_sids: std::slice::Iter<'a, i32>, // deltas
+    cuser_sid: i32,
+}
+
+impl<'a> DenseNodeInfoIter<'a> {
+    fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        info: &'a osmformat::DenseInfo,
+    ) -> DenseNodeInfoIter<'a> {
+        DenseNodeInfoIter {
+            block,
+            versions: info.get_version().iter(),
+            dtimestamps: info.get_timestamp().iter(),
+            ctimestamp: 0,
+            dchangesets: info.get_changeset().iter(),
+            cchangeset: 0,
+            duids: info.get_uid().iter(),
+            cuid: 0,
+            duser_sids: info.get_user_sid().iter(),
+            cuser_sid: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for DenseNodeInfoIter<'a> {
+    type Item = DenseNodeInfo<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match (
+            self.versions.next(),
+            self.dtimestamps.next(),
+            self.dchangesets.next(),
+            self.duids.next(),
+            self.duser_sids.next(),
+        ) {
+            (Some(&version), Some(dtimestamp), Some(dchangeset), Some(duid), Some(duser_sid)) => {
+                self.ctimestamp += *dtimestamp;
+                self.cchangeset += *dchangeset;
+                self.cuid += *duid;
+                self.cuser_sid += *duser_sid;
+                Some(DenseNodeInfo {
+                    block: self.block,
+                    version,
+                    timestamp: self.ctimestamp,
+                    changeset: self.cchangeset,
+                    uid: self.cuid,
+                    user_sid: self.cuser_sid,
+                })
+            }
+            _ => None,
+        }
+    }
+}
+
 /// An iterator over the tags in a dense node.
 #[derive(Clone, Debug)]
 pub struct DenseTagIter<'a> {

src/lib.rs

 
 ```toml
 [dependencies]
-osmpbf = "0.1"
+osmpbf = "0.2"
 ```
 
 and if you're using Rust 2015, add this line to the crate root:
 ```rust
 use osmpbf::{ElementReader, Element};
 
-let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+let reader = ElementReader::from_path("tests/test.osm.pbf")?;
 let mut ways = 0_u64;
 
 // Increment the counter by one for each way.
     if let Element::Way(_) = element {
         ways += 1;
     }
-}).unwrap();
+})?;
 
 println!("Number of ways: {}", ways);
+# assert_eq!(ways, 1);
+# Ok::<(), std::io::Error>(())
 ```
 
 ## Example: Count ways in parallel
 ```rust
 use osmpbf::{ElementReader, Element};
 
-let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+let reader = ElementReader::from_path("tests/test.osm.pbf")?;
 
 // Count the ways
 let ways = reader.par_map_reduce(
     },
     || 0_u64,      // Zero is the identity value for addition
     |a, b| a + b   // Sum the partial results
-).unwrap();
+)?;
 
 println!("Number of ways: {}", ways);
+# assert_eq!(ways, 1);
+# Ok::<(), std::io::Error>(())
 ```
 */
 

src/proto/fileformat.rs

-// This file is generated by rust-protobuf 2.10.1. Do not edit
+// This file is generated by rust-protobuf 2.17.0. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
-#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_attributes)]
+#![rustfmt::skip]
 
 #![allow(box_pointers)]
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]
 #![allow(trivial_casts)]
-#![allow(unsafe_code)]
 #![allow(unused_imports)]
 #![allow(unused_results)]
 //! Generated file from `src/proto/fileformat.proto`
 
-use protobuf::Message as Message_imported_for_functions;
-use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
-
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_1;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_17_0;
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct Blob {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static Blob {
-        static mut instance: ::protobuf::lazy::Lazy<Blob> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Blob,
-        };
-        unsafe {
-            instance.get(Blob::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<Blob> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(Blob::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Blob {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static BlobHeader {
-        static mut instance: ::protobuf::lazy::Lazy<BlobHeader> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const BlobHeader,
-        };
-        unsafe {
-            instance.get(BlobHeader::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<BlobHeader> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(BlobHeader::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for BlobHeader {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }

src/proto/osmformat.rs

-// This file is generated by rust-protobuf 2.10.1. Do not edit
+// This file is generated by rust-protobuf 2.17.0. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
-#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_attributes)]
+#![rustfmt::skip]
 
 #![allow(box_pointers)]
 #![allow(dead_code)]
 #![allow(non_snake_case)]
 #![allow(non_upper_case_globals)]
 #![allow(trivial_casts)]
-#![allow(unsafe_code)]
 #![allow(unused_imports)]
 #![allow(unused_results)]
 //! Generated file from `src/proto/osmformat.proto`
 
-use protobuf::Message as Message_imported_for_functions;
-use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
-
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_1;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_17_0;
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct HeaderBlock {
     // message fields
-    bbox: ::protobuf::SingularPtrField<HeaderBBox>,
-    required_features: ::protobuf::RepeatedField<::std::string::String>,
-    optional_features: ::protobuf::RepeatedField<::std::string::String>,
+    pub bbox: ::protobuf::SingularPtrField<HeaderBBox>,
+    pub required_features: ::protobuf::RepeatedField<::std::string::String>,
+    pub optional_features: ::protobuf::RepeatedField<::std::string::String>,
     writingprogram: ::protobuf::SingularField<::std::string::String>,
     source: ::protobuf::SingularField<::std::string::String>,
     osmosis_replication_timestamp: ::std::option::Option<i64>,
 
 
     pub fn get_bbox(&self) -> &HeaderBBox {
-        self.bbox.as_ref().unwrap_or_else(|| HeaderBBox::default_instance())
+        self.bbox.as_ref().unwrap_or_else(|| <HeaderBBox as ::protobuf::Message>::default_instance())
     }
     pub fn clear_bbox(&mut self) {
         self.bbox.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static HeaderBlock {
-        static mut instance: ::protobuf::lazy::Lazy<HeaderBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const HeaderBlock,
-        };
-        unsafe {
-            instance.get(HeaderBlock::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<HeaderBlock> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(HeaderBlock::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for HeaderBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static HeaderBBox {
-        static mut instance: ::protobuf::lazy::Lazy<HeaderBBox> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const HeaderBBox,
-        };
-        unsafe {
-            instance.get(HeaderBBox::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<HeaderBBox> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(HeaderBBox::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for HeaderBBox {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct PrimitiveBlock {
     // message fields
-    stringtable: ::protobuf::SingularPtrField<StringTable>,
-    primitivegroup: ::protobuf::RepeatedField<PrimitiveGroup>,
+    pub stringtable: ::protobuf::SingularPtrField<StringTable>,
+    pub primitivegroup: ::protobuf::RepeatedField<PrimitiveGroup>,
     granularity: ::std::option::Option<i32>,
     lat_offset: ::std::option::Option<i64>,
     lon_offset: ::std::option::Option<i64>,
 
 
     pub fn get_stringtable(&self) -> &StringTable {
-        self.stringtable.as_ref().unwrap_or_else(|| StringTable::default_instance())
+        self.stringtable.as_ref().unwrap_or_else(|| <StringTable as ::protobuf::Message>::default_instance())
     }
     pub fn clear_stringtable(&mut self) {
         self.stringtable.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static PrimitiveBlock {
-        static mut instance: ::protobuf::lazy::Lazy<PrimitiveBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const PrimitiveBlock,
-        };
-        unsafe {
-            instance.get(PrimitiveBlock::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<PrimitiveBlock> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(PrimitiveBlock::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for PrimitiveBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct PrimitiveGroup {
     // message fields
-    nodes: ::protobuf::RepeatedField<Node>,
-    dense: ::protobuf::SingularPtrField<DenseNodes>,
-    ways: ::protobuf::RepeatedField<Way>,
-    relations: ::protobuf::RepeatedField<Relation>,
-    changesets: ::protobuf::RepeatedField<ChangeSet>,
+    pub nodes: ::protobuf::RepeatedField<Node>,
+    pub dense: ::protobuf::SingularPtrField<DenseNodes>,
+    pub ways: ::protobuf::RepeatedField<Way>,
+    pub relations: ::protobuf::RepeatedField<Relation>,
+    pub changesets: ::protobuf::RepeatedField<ChangeSet>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
 
 
     pub fn get_dense(&self) -> &DenseNodes {
-        self.dense.as_ref().unwrap_or_else(|| DenseNodes::default_instance())
+        self.dense.as_ref().unwrap_or_else(|| <DenseNodes as ::protobuf::Message>::default_instance())
     }
     pub fn clear_dense(&mut self) {
         self.dense.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static PrimitiveGroup {
-        static mut instance: ::protobuf::lazy::Lazy<PrimitiveGroup> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const PrimitiveGroup,
-        };
-        unsafe {
-            instance.get(PrimitiveGroup::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<PrimitiveGroup> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(PrimitiveGroup::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for PrimitiveGroup {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct StringTable {
     // message fields
-    s: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
+    pub s: ::protobuf::RepeatedField<::std::vec::Vec<u8>>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static StringTable {
-        static mut instance: ::protobuf::lazy::Lazy<StringTable> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const StringTable,
-        };
-        unsafe {
-            instance.get(StringTable::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<StringTable> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(StringTable::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for StringTable {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static Info {
-        static mut instance: ::protobuf::lazy::Lazy<Info> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Info,
-        };
-        unsafe {
-            instance.get(Info::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<Info> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(Info::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Info {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct DenseInfo {
     // message fields
-    version: ::std::vec::Vec<i32>,
-    timestamp: ::std::vec::Vec<i64>,
-    changeset: ::std::vec::Vec<i64>,
-    uid: ::std::vec::Vec<i32>,
-    user_sid: ::std::vec::Vec<i32>,
-    visible: ::std::vec::Vec<bool>,
+    pub version: ::std::vec::Vec<i32>,
+    pub timestamp: ::std::vec::Vec<i64>,
+    pub changeset: ::std::vec::Vec<i64>,
+    pub uid: ::std::vec::Vec<i32>,
+    pub user_sid: ::std::vec::Vec<i32>,
+    pub visible: ::std::vec::Vec<bool>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static DenseInfo {
-        static mut instance: ::protobuf::lazy::Lazy<DenseInfo> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const DenseInfo,
-        };
-        unsafe {
-            instance.get(DenseInfo::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<DenseInfo> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(DenseInfo::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for DenseInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static ChangeSet {
-        static mut instance: ::protobuf::lazy::Lazy<ChangeSet> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ChangeSet,
-        };
-        unsafe {
-            instance.get(ChangeSet::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<ChangeSet> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(ChangeSet::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for ChangeSet {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 pub struct Node {
     // message fields
     id: ::std::option::Option<i64>,
-    keys: ::std::vec::Vec<u32>,
-    vals: ::std::vec::Vec<u32>,
-    info: ::protobuf::SingularPtrField<Info>,
+    pub keys: ::std::vec::Vec<u32>,
+    pub vals: ::std::vec::Vec<u32>,
+    pub info: ::protobuf::SingularPtrField<Info>,
     lat: ::std::option::Option<i64>,
     lon: ::std::option::Option<i64>,
     // special fields
 
 
     pub fn get_info(&self) -> &Info {
-        self.info.as_ref().unwrap_or_else(|| Info::default_instance())
+        self.info.as_ref().unwrap_or_else(|| <Info as ::protobuf::Message>::default_instance())
     }
     pub fn clear_info(&mut self) {
         self.info.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static Node {
-        static mut instance: ::protobuf::lazy::Lazy<Node> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Node,
-        };
-        unsafe {
-            instance.get(Node::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<Node> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(Node::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Node {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct DenseNodes {
     // message fields
-    id: ::std::vec::Vec<i64>,
-    denseinfo: ::protobuf::SingularPtrField<DenseInfo>,
-    lat: ::std::vec::Vec<i64>,
-    lon: ::std::vec::Vec<i64>,
-    keys_vals: ::std::vec::Vec<i32>,
+    pub id: ::std::vec::Vec<i64>,
+    pub denseinfo: ::protobuf::SingularPtrField<DenseInfo>,
+    pub lat: ::std::vec::Vec<i64>,
+    pub lon: ::std::vec::Vec<i64>,
+    pub keys_vals: ::std::vec::Vec<i32>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
 
 
     pub fn get_denseinfo(&self) -> &DenseInfo {
-        self.denseinfo.as_ref().unwrap_or_else(|| DenseInfo::default_instance())
+        self.denseinfo.as_ref().unwrap_or_else(|| <DenseInfo as ::protobuf::Message>::default_instance())
     }
     pub fn clear_denseinfo(&mut self) {
         self.denseinfo.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static DenseNodes {
-        static mut instance: ::protobuf::lazy::Lazy<DenseNodes> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const DenseNodes,
-        };
-        unsafe {
-            instance.get(DenseNodes::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<DenseNodes> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(DenseNodes::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for DenseNodes {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 pub struct Way {
     // message fields
     id: ::std::option::Option<i64>,
-    keys: ::std::vec::Vec<u32>,
-    vals: ::std::vec::Vec<u32>,
-    info: ::protobuf::SingularPtrField<Info>,
-    refs: ::std::vec::Vec<i64>,
+    pub keys: ::std::vec::Vec<u32>,
+    pub vals: ::std::vec::Vec<u32>,
+    pub info: ::protobuf::SingularPtrField<Info>,
+    pub refs: ::std::vec::Vec<i64>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
 
 
     pub fn get_info(&self) -> &Info {
-        self.info.as_ref().unwrap_or_else(|| Info::default_instance())
+        self.info.as_ref().unwrap_or_else(|| <Info as ::protobuf::Message>::default_instance())
     }
     pub fn clear_info(&mut self) {
         self.info.clear();
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static Way {
-        static mut instance: ::protobuf::lazy::Lazy<Way> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Way,
-        };
-        unsafe {
-            instance.get(Way::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<Way> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(Way::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Way {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 pub struct Relation {
     // message fields
     id: ::std::option::Option<i64>,
-    keys: ::std::vec::Vec<u32>,
-    vals: ::std::vec::Vec<u32>,
-    info: ::protobuf::SingularPtrField<Info>,
-    roles_sid: ::std::vec::Vec<i32>,
-    memids: ::std::vec::Vec<i64>,
-    types: ::std::vec::Vec<Relation_MemberType>,
+    pub keys: ::std::vec::Vec<u32>,
+    pub vals: ::std::vec::Vec<u32>,
+    pub info: ::protobuf::SingularPtrField<Info>,
+    pub roles_sid: ::std::vec::Vec<i32>,
+    pub memids: ::std::vec::Vec<i64>,
+    pub types: ::std::vec::Vec<Relation_MemberType>,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
 
 
     pub fn get_info(&self) -> &Info {
-        self.info.as_ref().unwrap_or_else(|| Info::default_instance())
+        self.info.as_ref().unwrap_or_else(|| <Info as ::protobuf::Message>::default_instance())
     }
     pub fn clear_info(&mut self) {
         self.info.clear();
             // TODO: Data size is computed again, it should be cached
             os.write_raw_varint32(::protobuf::rt::vec_packed_enum_data_size(&self.types))?;
             for v in &self.types {
-                os.write_enum_no_tag(v.value())?;
+                os.write_enum_no_tag(::protobuf::ProtobufEnum::value(v))?;
             };
         }
         os.write_unknown_fields(self.get_unknown_fields())?;
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
     }
 
     fn default_instance() -> &'static Relation {
-        static mut instance: ::protobuf::lazy::Lazy<Relation> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Relation,
-        };
-        unsafe {
-            instance.get(Relation::new)
-        }
+        static instance: ::protobuf::rt::LazyV2<Relation> = ::protobuf::rt::LazyV2::INIT;
+        instance.get(Relation::new)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Relation {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 }
 
 impl ::protobuf::reflect::ProtobufValue for Relation_MemberType {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self))
     }
 }

tests/read.rs

         assert_eq!(dense_nodes[1].id, 106);
         assert_eq!(dense_nodes[2].id, 108);
 
-        assert_eq!(dense_nodes[0].uid, 17);
-        assert_eq!(dense_nodes[1].uid, 17);
-        assert_eq!(dense_nodes[2].uid, 17);
+        assert_eq!(dense_nodes[0].info().map(|x| x.uid()), Some(17));
+        assert_eq!(dense_nodes[1].info().map(|x| x.uid()), Some(17));
+        assert_eq!(dense_nodes[2].info().map(|x| x.uid()), Some(17));
     }
 
     {