for new protobuf version 2.17.0

.appveyor.yml

@@ -16,7 +16,7 @@ environment:
       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

@@ -4,11 +4,10 @@ rust:
   - 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

@@ -1,6 +1,6 @@
 [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"
@@ -21,7 +21,7 @@ default = ["system-libz"]
 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

@@ -16,7 +16,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-osmpbf = "0.1"
+osmpbf = "0.2"
 ```
 
 and if you're using Rust 2015, add this line to the crate root:
@@ -28,48 +28,42 @@ extern crate osmpbf;
 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

@@ -14,12 +14,9 @@ fn main() {
         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

@@ -14,23 +14,16 @@ pub struct DenseNode<'a> {
     /// 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.
@@ -63,11 +56,6 @@ impl<'a> DenseNode<'a> {
         (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 {
@@ -91,23 +79,15 @@ impl<'a> DenseNode<'a> {
 #[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> {
@@ -115,26 +95,18 @@ 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,
         }
     }
 
@@ -143,21 +115,13 @@ impl<'a> DenseNodeIter<'a> {
             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,
         }
     }
 }
@@ -168,29 +132,12 @@ impl<'a> Iterator for DenseNodeIter<'a> {
     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;
 
@@ -209,14 +156,10 @@ impl<'a> Iterator for DenseNodeIter<'a> {
                 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,
@@ -230,6 +173,114 @@ impl<'a> Iterator for DenseNodeIter<'a> {
 
 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

@@ -7,7 +7,7 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-osmpbf = "0.1"
+osmpbf = "0.2"
 ```
 
 and if you're using Rust 2015, add this line to the crate root:
@@ -24,7 +24,7 @@ file:
 ```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.
@@ -32,9 +32,11 @@ reader.for_each(|element| {
     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
@@ -45,7 +47,7 @@ decoding the file 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(
@@ -57,9 +59,11 @@ 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

@@ -1,11 +1,12 @@
-// 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)]
@@ -14,17 +15,13 @@
 #![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 {
@@ -312,7 +309,7 @@ impl ::protobuf::Message for 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
     }
 
@@ -325,13 +322,8 @@ impl ::protobuf::Message for Blob {
     }
 
     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)
     }
 }
 
@@ -347,8 +339,8 @@ impl ::protobuf::Clear for Blob {
 }
 
 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)
     }
 }
 
@@ -552,7 +544,7 @@ impl ::protobuf::Message for BlobHeader {
     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
     }
 
@@ -565,13 +557,8 @@ impl ::protobuf::Message for BlobHeader {
     }
 
     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)
     }
 }
 
@@ -585,7 +572,7 @@ impl ::protobuf::Clear for BlobHeader {
 }
 
 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

@@ -1,11 +1,12 @@
-// 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)]
@@ -14,24 +15,20 @@
 #![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>,
@@ -57,7 +54,7 @@ impl HeaderBlock {
 
 
     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();
@@ -420,7 +417,7 @@ impl ::protobuf::Message for HeaderBlock {
     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
     }
 
@@ -433,13 +430,8 @@ impl ::protobuf::Message for HeaderBlock {
     }
 
     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)
     }
 }
 
@@ -458,8 +450,8 @@ impl ::protobuf::Clear for HeaderBlock {
 }
 
 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)
     }
 }
 
@@ -676,7 +668,7 @@ impl ::protobuf::Message for HeaderBBox {
     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
     }
 
@@ -689,13 +681,8 @@ impl ::protobuf::Message for HeaderBBox {
     }
 
     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)
     }
 }
 
@@ -710,16 +697,16 @@ impl ::protobuf::Clear for HeaderBBox {
 }
 
 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>,
@@ -744,7 +731,7 @@ impl PrimitiveBlock {
 
 
     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();
@@ -1013,7 +1000,7 @@ impl ::protobuf::Message for PrimitiveBlock {
     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
     }
 
@@ -1026,13 +1013,8 @@ impl ::protobuf::Message for PrimitiveBlock {
     }
 
     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)
     }
 }
 
@@ -1049,19 +1031,19 @@ impl ::protobuf::Clear for PrimitiveBlock {
 }
 
 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,
@@ -1107,7 +1089,7 @@ impl PrimitiveGroup {
 
 
     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();
@@ -1346,7 +1328,7 @@ impl ::protobuf::Message for PrimitiveGroup {
     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
     }
 
@@ -1359,13 +1341,8 @@ impl ::protobuf::Message for PrimitiveGroup {
     }
 
     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)
     }
 }
 
@@ -1381,15 +1358,15 @@ impl ::protobuf::Clear for PrimitiveGroup {
 }
 
 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,
@@ -1490,7 +1467,7 @@ impl ::protobuf::Message for StringTable {
     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
     }
 
@@ -1503,13 +1480,8 @@ impl ::protobuf::Message for StringTable {
     }
 
     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)
     }
 }
 
@@ -1521,8 +1493,8 @@ impl ::protobuf::Clear for StringTable {
 }
 
 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)
     }
 }
 
@@ -1793,7 +1765,7 @@ impl ::protobuf::Message for Info {
     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
     }
 
@@ -1806,13 +1778,8 @@ impl ::protobuf::Message for Info {
     }
 
     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)
     }
 }
 
@@ -1829,20 +1796,20 @@ impl ::protobuf::Clear for Info {
 }
 
 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,
@@ -2143,7 +2110,7 @@ impl ::protobuf::Message for DenseInfo {
     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
     }
 
@@ -2156,13 +2123,8 @@ impl ::protobuf::Message for DenseInfo {
     }
 
     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)
     }
 }
 
@@ -2179,8 +2141,8 @@ impl ::protobuf::Clear for DenseInfo {
 }
 
 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)
     }
 }
 
@@ -2289,7 +2251,7 @@ impl ::protobuf::Message for ChangeSet {
     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
     }
 
@@ -2302,13 +2264,8 @@ impl ::protobuf::Message for ChangeSet {
     }
 
     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)
     }
 }
 
@@ -2320,8 +2277,8 @@ impl ::protobuf::Clear for ChangeSet {
 }
 
 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)
     }
 }
 
@@ -2329,9 +2286,9 @@ impl ::protobuf::reflect::ProtobufValue for ChangeSet {
 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
@@ -2423,7 +2380,7 @@ impl Node {
 
 
     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();
@@ -2633,7 +2590,7 @@ impl ::protobuf::Message for Node {
     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
     }
 
@@ -2646,13 +2603,8 @@ impl ::protobuf::Message for Node {
     }
 
     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)
     }
 }
 
@@ -2669,19 +2621,19 @@ impl ::protobuf::Clear for Node {
 }
 
 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,
@@ -2727,7 +2679,7 @@ impl DenseNodes {
 
 
     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();
@@ -2954,7 +2906,7 @@ impl ::protobuf::Message for DenseNodes {
     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
     }
 
@@ -2967,13 +2919,8 @@ impl ::protobuf::Message for DenseNodes {
     }
 
     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)
     }
 }
 
@@ -2989,8 +2936,8 @@ impl ::protobuf::Clear for DenseNodes {
 }
 
 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)
     }
 }
 
@@ -2998,10 +2945,10 @@ impl ::protobuf::reflect::ProtobufValue for DenseNodes {
 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,
@@ -3091,7 +3038,7 @@ impl Way {
 
 
     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();
@@ -3270,7 +3217,7 @@ impl ::protobuf::Message for Way {
     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
     }
 
@@ -3283,13 +3230,8 @@ impl ::protobuf::Message for Way {
     }
 
     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)
     }
 }
 
@@ -3305,8 +3247,8 @@ impl ::protobuf::Clear for Way {
 }
 
 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)
     }
 }
 
@@ -3314,12 +3256,12 @@ impl ::protobuf::reflect::ProtobufValue for Way {
 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,
@@ -3409,7 +3351,7 @@ impl Relation {
 
 
     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();
@@ -3641,7 +3583,7 @@ impl ::protobuf::Message for Relation {
             // 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())?;
@@ -3666,7 +3608,7 @@ impl ::protobuf::Message for Relation {
     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
     }
 
@@ -3679,13 +3621,8 @@ impl ::protobuf::Message for Relation {
     }
 
     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)
     }
 }
 
@@ -3703,8 +3640,8 @@ impl ::protobuf::Clear for Relation {
 }
 
 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)
     }
 }
 
@@ -3749,7 +3686,7 @@ impl ::std::default::Default for Relation_MemberType {
 }
 
 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

@@ -81,9 +81,9 @@ fn check_primitive_block_content(block: &PrimitiveBlock) {
         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));
     }
 
     {