osmio 0.16.1

// This file is generated by rust-protobuf 3.7.2. Do not edit
// .proto file is parsed by protoc --rs_out=...
// @generated

// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]

#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]

#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_results)]
#![allow(unused_mut)]

//! Generated file from `osmformat.proto`
// Generated for lite runtime

/// Generated files are compatible only with the same version
/// of protobuf runtime.
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_7_2;

// @@protoc_insertion_point(message:OSMPBF.HeaderBlock)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct HeaderBlock {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.bbox)
    pub bbox: ::protobuf::MessageField<HeaderBBox>,
    ///  Additional tags to aid in parsing this dataset 
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.required_features)
    pub required_features: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.optional_features)
    pub optional_features: ::std::vec::Vec<::std::string::String>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.writingprogram)
    pub writingprogram: ::std::option::Option<::std::string::String>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.source)
    pub source: ::std::option::Option<::std::string::String>,
    ///  replication timestamp, expressed in seconds since the epoch, 
    ///  otherwise the same value as in the "timestamp=..." field
    ///  in the state.txt file used by Osmosis
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.osmosis_replication_timestamp)
    pub osmosis_replication_timestamp: ::std::option::Option<i64>,
    ///  replication sequence number (sequenceNumber in state.txt)
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.osmosis_replication_sequence_number)
    pub osmosis_replication_sequence_number: ::std::option::Option<i64>,
    ///  replication base URL (from Osmosis' configuration.txt file)
    // @@protoc_insertion_point(field:OSMPBF.HeaderBlock.osmosis_replication_base_url)
    pub osmosis_replication_base_url: ::std::option::Option<::std::string::String>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.HeaderBlock.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a HeaderBlock {
    fn default() -> &'a HeaderBlock {
        <HeaderBlock as ::protobuf::Message>::default_instance()
    }
}

impl HeaderBlock {
    pub fn new() -> HeaderBlock {
        ::std::default::Default::default()
    }

    // optional string writingprogram = 16;

    pub fn writingprogram(&self) -> &str {
        match self.writingprogram.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_writingprogram(&mut self) {
        self.writingprogram = ::std::option::Option::None;
    }

    pub fn has_writingprogram(&self) -> bool {
        self.writingprogram.is_some()
    }

    // Param is passed by value, moved
    pub fn set_writingprogram(&mut self, v: ::std::string::String) {
        self.writingprogram = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_writingprogram(&mut self) -> &mut ::std::string::String {
        if self.writingprogram.is_none() {
            self.writingprogram = ::std::option::Option::Some(::std::string::String::new());
        }
        self.writingprogram.as_mut().unwrap()
    }

    // Take field
    pub fn take_writingprogram(&mut self) -> ::std::string::String {
        self.writingprogram.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional string source = 17;

    pub fn source(&self) -> &str {
        match self.source.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_source(&mut self) {
        self.source = ::std::option::Option::None;
    }

    pub fn has_source(&self) -> bool {
        self.source.is_some()
    }

    // Param is passed by value, moved
    pub fn set_source(&mut self, v: ::std::string::String) {
        self.source = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_source(&mut self) -> &mut ::std::string::String {
        if self.source.is_none() {
            self.source = ::std::option::Option::Some(::std::string::String::new());
        }
        self.source.as_mut().unwrap()
    }

    // Take field
    pub fn take_source(&mut self) -> ::std::string::String {
        self.source.take().unwrap_or_else(|| ::std::string::String::new())
    }

    // optional int64 osmosis_replication_timestamp = 32;

    pub fn osmosis_replication_timestamp(&self) -> i64 {
        self.osmosis_replication_timestamp.unwrap_or(0)
    }

    pub fn clear_osmosis_replication_timestamp(&mut self) {
        self.osmosis_replication_timestamp = ::std::option::Option::None;
    }

    pub fn has_osmosis_replication_timestamp(&self) -> bool {
        self.osmosis_replication_timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_osmosis_replication_timestamp(&mut self, v: i64) {
        self.osmosis_replication_timestamp = ::std::option::Option::Some(v);
    }

    // optional int64 osmosis_replication_sequence_number = 33;

    pub fn osmosis_replication_sequence_number(&self) -> i64 {
        self.osmosis_replication_sequence_number.unwrap_or(0)
    }

    pub fn clear_osmosis_replication_sequence_number(&mut self) {
        self.osmosis_replication_sequence_number = ::std::option::Option::None;
    }

    pub fn has_osmosis_replication_sequence_number(&self) -> bool {
        self.osmosis_replication_sequence_number.is_some()
    }

    // Param is passed by value, moved
    pub fn set_osmosis_replication_sequence_number(&mut self, v: i64) {
        self.osmosis_replication_sequence_number = ::std::option::Option::Some(v);
    }

    // optional string osmosis_replication_base_url = 34;

    pub fn osmosis_replication_base_url(&self) -> &str {
        match self.osmosis_replication_base_url.as_ref() {
            Some(v) => v,
            None => "",
        }
    }

    pub fn clear_osmosis_replication_base_url(&mut self) {
        self.osmosis_replication_base_url = ::std::option::Option::None;
    }

    pub fn has_osmosis_replication_base_url(&self) -> bool {
        self.osmosis_replication_base_url.is_some()
    }

    // Param is passed by value, moved
    pub fn set_osmosis_replication_base_url(&mut self, v: ::std::string::String) {
        self.osmosis_replication_base_url = ::std::option::Option::Some(v);
    }

    // Mutable pointer to the field.
    // If field is not initialized, it is initialized with default value first.
    pub fn mut_osmosis_replication_base_url(&mut self) -> &mut ::std::string::String {
        if self.osmosis_replication_base_url.is_none() {
            self.osmosis_replication_base_url = ::std::option::Option::Some(::std::string::String::new());
        }
        self.osmosis_replication_base_url.as_mut().unwrap()
    }

    // Take field
    pub fn take_osmosis_replication_base_url(&mut self) -> ::std::string::String {
        self.osmosis_replication_base_url.take().unwrap_or_else(|| ::std::string::String::new())
    }
}

impl ::protobuf::Message for HeaderBlock {
    const NAME: &'static str = "HeaderBlock";

    fn is_initialized(&self) -> bool {
        for v in &self.bbox {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.bbox)?;
                },
                34 => {
                    self.required_features.push(is.read_string()?);
                },
                42 => {
                    self.optional_features.push(is.read_string()?);
                },
                130 => {
                    self.writingprogram = ::std::option::Option::Some(is.read_string()?);
                },
                138 => {
                    self.source = ::std::option::Option::Some(is.read_string()?);
                },
                256 => {
                    self.osmosis_replication_timestamp = ::std::option::Option::Some(is.read_int64()?);
                },
                264 => {
                    self.osmosis_replication_sequence_number = ::std::option::Option::Some(is.read_int64()?);
                },
                274 => {
                    self.osmosis_replication_base_url = ::std::option::Option::Some(is.read_string()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.bbox.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.required_features {
            my_size += ::protobuf::rt::string_size(4, &value);
        };
        for value in &self.optional_features {
            my_size += ::protobuf::rt::string_size(5, &value);
        };
        if let Some(v) = self.writingprogram.as_ref() {
            my_size += ::protobuf::rt::string_size(16, &v);
        }
        if let Some(v) = self.source.as_ref() {
            my_size += ::protobuf::rt::string_size(17, &v);
        }
        if let Some(v) = self.osmosis_replication_timestamp {
            my_size += ::protobuf::rt::int64_size(32, v);
        }
        if let Some(v) = self.osmosis_replication_sequence_number {
            my_size += ::protobuf::rt::int64_size(33, v);
        }
        if let Some(v) = self.osmosis_replication_base_url.as_ref() {
            my_size += ::protobuf::rt::string_size(34, &v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.bbox.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.required_features {
            os.write_string(4, &v)?;
        };
        for v in &self.optional_features {
            os.write_string(5, &v)?;
        };
        if let Some(v) = self.writingprogram.as_ref() {
            os.write_string(16, v)?;
        }
        if let Some(v) = self.source.as_ref() {
            os.write_string(17, v)?;
        }
        if let Some(v) = self.osmosis_replication_timestamp {
            os.write_int64(32, v)?;
        }
        if let Some(v) = self.osmosis_replication_sequence_number {
            os.write_int64(33, v)?;
        }
        if let Some(v) = self.osmosis_replication_base_url.as_ref() {
            os.write_string(34, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> HeaderBlock {
        HeaderBlock::new()
    }

    fn clear(&mut self) {
        self.bbox.clear();
        self.required_features.clear();
        self.optional_features.clear();
        self.writingprogram = ::std::option::Option::None;
        self.source = ::std::option::Option::None;
        self.osmosis_replication_timestamp = ::std::option::Option::None;
        self.osmosis_replication_sequence_number = ::std::option::Option::None;
        self.osmosis_replication_base_url = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static HeaderBlock {
        static instance: HeaderBlock = HeaderBlock {
            bbox: ::protobuf::MessageField::none(),
            required_features: ::std::vec::Vec::new(),
            optional_features: ::std::vec::Vec::new(),
            writingprogram: ::std::option::Option::None,
            source: ::std::option::Option::None,
            osmosis_replication_timestamp: ::std::option::Option::None,
            osmosis_replication_sequence_number: ::std::option::Option::None,
            osmosis_replication_base_url: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.HeaderBBox)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct HeaderBBox {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.HeaderBBox.left)
    pub left: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBBox.right)
    pub right: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBBox.top)
    pub top: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.HeaderBBox.bottom)
    pub bottom: ::std::option::Option<i64>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.HeaderBBox.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a HeaderBBox {
    fn default() -> &'a HeaderBBox {
        <HeaderBBox as ::protobuf::Message>::default_instance()
    }
}

impl HeaderBBox {
    pub fn new() -> HeaderBBox {
        ::std::default::Default::default()
    }

    // required sint64 left = 1;

    pub fn left(&self) -> i64 {
        self.left.unwrap_or(0)
    }

    pub fn clear_left(&mut self) {
        self.left = ::std::option::Option::None;
    }

    pub fn has_left(&self) -> bool {
        self.left.is_some()
    }

    // Param is passed by value, moved
    pub fn set_left(&mut self, v: i64) {
        self.left = ::std::option::Option::Some(v);
    }

    // required sint64 right = 2;

    pub fn right(&self) -> i64 {
        self.right.unwrap_or(0)
    }

    pub fn clear_right(&mut self) {
        self.right = ::std::option::Option::None;
    }

    pub fn has_right(&self) -> bool {
        self.right.is_some()
    }

    // Param is passed by value, moved
    pub fn set_right(&mut self, v: i64) {
        self.right = ::std::option::Option::Some(v);
    }

    // required sint64 top = 3;

    pub fn top(&self) -> i64 {
        self.top.unwrap_or(0)
    }

    pub fn clear_top(&mut self) {
        self.top = ::std::option::Option::None;
    }

    pub fn has_top(&self) -> bool {
        self.top.is_some()
    }

    // Param is passed by value, moved
    pub fn set_top(&mut self, v: i64) {
        self.top = ::std::option::Option::Some(v);
    }

    // required sint64 bottom = 4;

    pub fn bottom(&self) -> i64 {
        self.bottom.unwrap_or(0)
    }

    pub fn clear_bottom(&mut self) {
        self.bottom = ::std::option::Option::None;
    }

    pub fn has_bottom(&self) -> bool {
        self.bottom.is_some()
    }

    // Param is passed by value, moved
    pub fn set_bottom(&mut self, v: i64) {
        self.bottom = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for HeaderBBox {
    const NAME: &'static str = "HeaderBBox";

    fn is_initialized(&self) -> bool {
        if self.left.is_none() {
            return false;
        }
        if self.right.is_none() {
            return false;
        }
        if self.top.is_none() {
            return false;
        }
        if self.bottom.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.left = ::std::option::Option::Some(is.read_sint64()?);
                },
                16 => {
                    self.right = ::std::option::Option::Some(is.read_sint64()?);
                },
                24 => {
                    self.top = ::std::option::Option::Some(is.read_sint64()?);
                },
                32 => {
                    self.bottom = ::std::option::Option::Some(is.read_sint64()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.left {
            my_size += ::protobuf::rt::sint64_size(1, v);
        }
        if let Some(v) = self.right {
            my_size += ::protobuf::rt::sint64_size(2, v);
        }
        if let Some(v) = self.top {
            my_size += ::protobuf::rt::sint64_size(3, v);
        }
        if let Some(v) = self.bottom {
            my_size += ::protobuf::rt::sint64_size(4, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.left {
            os.write_sint64(1, v)?;
        }
        if let Some(v) = self.right {
            os.write_sint64(2, v)?;
        }
        if let Some(v) = self.top {
            os.write_sint64(3, v)?;
        }
        if let Some(v) = self.bottom {
            os.write_sint64(4, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> HeaderBBox {
        HeaderBBox::new()
    }

    fn clear(&mut self) {
        self.left = ::std::option::Option::None;
        self.right = ::std::option::Option::None;
        self.top = ::std::option::Option::None;
        self.bottom = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static HeaderBBox {
        static instance: HeaderBBox = HeaderBBox {
            left: ::std::option::Option::None,
            right: ::std::option::Option::None,
            top: ::std::option::Option::None,
            bottom: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.PrimitiveBlock)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PrimitiveBlock {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.stringtable)
    pub stringtable: ::protobuf::MessageField<StringTable>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.primitivegroup)
    pub primitivegroup: ::std::vec::Vec<PrimitiveGroup>,
    ///  Granularity, units of nanodegrees, used to store coordinates in this block
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.granularity)
    pub granularity: ::std::option::Option<i32>,
    ///  Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.lat_offset)
    pub lat_offset: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.lon_offset)
    pub lon_offset: ::std::option::Option<i64>,
    ///  Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveBlock.date_granularity)
    pub date_granularity: ::std::option::Option<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.PrimitiveBlock.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a PrimitiveBlock {
    fn default() -> &'a PrimitiveBlock {
        <PrimitiveBlock as ::protobuf::Message>::default_instance()
    }
}

impl PrimitiveBlock {
    pub fn new() -> PrimitiveBlock {
        ::std::default::Default::default()
    }

    // optional int32 granularity = 17;

    pub fn granularity(&self) -> i32 {
        self.granularity.unwrap_or(100i32)
    }

    pub fn clear_granularity(&mut self) {
        self.granularity = ::std::option::Option::None;
    }

    pub fn has_granularity(&self) -> bool {
        self.granularity.is_some()
    }

    // Param is passed by value, moved
    pub fn set_granularity(&mut self, v: i32) {
        self.granularity = ::std::option::Option::Some(v);
    }

    // optional int64 lat_offset = 19;

    pub fn lat_offset(&self) -> i64 {
        self.lat_offset.unwrap_or(0i64)
    }

    pub fn clear_lat_offset(&mut self) {
        self.lat_offset = ::std::option::Option::None;
    }

    pub fn has_lat_offset(&self) -> bool {
        self.lat_offset.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lat_offset(&mut self, v: i64) {
        self.lat_offset = ::std::option::Option::Some(v);
    }

    // optional int64 lon_offset = 20;

    pub fn lon_offset(&self) -> i64 {
        self.lon_offset.unwrap_or(0i64)
    }

    pub fn clear_lon_offset(&mut self) {
        self.lon_offset = ::std::option::Option::None;
    }

    pub fn has_lon_offset(&self) -> bool {
        self.lon_offset.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lon_offset(&mut self, v: i64) {
        self.lon_offset = ::std::option::Option::Some(v);
    }

    // optional int32 date_granularity = 18;

    pub fn date_granularity(&self) -> i32 {
        self.date_granularity.unwrap_or(1000i32)
    }

    pub fn clear_date_granularity(&mut self) {
        self.date_granularity = ::std::option::Option::None;
    }

    pub fn has_date_granularity(&self) -> bool {
        self.date_granularity.is_some()
    }

    // Param is passed by value, moved
    pub fn set_date_granularity(&mut self, v: i32) {
        self.date_granularity = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for PrimitiveBlock {
    const NAME: &'static str = "PrimitiveBlock";

    fn is_initialized(&self) -> bool {
        if self.stringtable.is_none() {
            return false;
        }
        for v in &self.stringtable {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.primitivegroup {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.stringtable)?;
                },
                18 => {
                    self.primitivegroup.push(is.read_message()?);
                },
                136 => {
                    self.granularity = ::std::option::Option::Some(is.read_int32()?);
                },
                152 => {
                    self.lat_offset = ::std::option::Option::Some(is.read_int64()?);
                },
                160 => {
                    self.lon_offset = ::std::option::Option::Some(is.read_int64()?);
                },
                144 => {
                    self.date_granularity = ::std::option::Option::Some(is.read_int32()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.stringtable.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.primitivegroup {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.granularity {
            my_size += ::protobuf::rt::int32_size(17, v);
        }
        if let Some(v) = self.lat_offset {
            my_size += ::protobuf::rt::int64_size(19, v);
        }
        if let Some(v) = self.lon_offset {
            my_size += ::protobuf::rt::int64_size(20, v);
        }
        if let Some(v) = self.date_granularity {
            my_size += ::protobuf::rt::int32_size(18, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.stringtable.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        }
        for v in &self.primitivegroup {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        };
        if let Some(v) = self.granularity {
            os.write_int32(17, v)?;
        }
        if let Some(v) = self.lat_offset {
            os.write_int64(19, v)?;
        }
        if let Some(v) = self.lon_offset {
            os.write_int64(20, v)?;
        }
        if let Some(v) = self.date_granularity {
            os.write_int32(18, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> PrimitiveBlock {
        PrimitiveBlock::new()
    }

    fn clear(&mut self) {
        self.stringtable.clear();
        self.primitivegroup.clear();
        self.granularity = ::std::option::Option::None;
        self.lat_offset = ::std::option::Option::None;
        self.lon_offset = ::std::option::Option::None;
        self.date_granularity = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PrimitiveBlock {
        static instance: PrimitiveBlock = PrimitiveBlock {
            stringtable: ::protobuf::MessageField::none(),
            primitivegroup: ::std::vec::Vec::new(),
            granularity: ::std::option::Option::None,
            lat_offset: ::std::option::Option::None,
            lon_offset: ::std::option::Option::None,
            date_granularity: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

///  Group of OSMPrimitives. All primitives in a group must be the same type.
// @@protoc_insertion_point(message:OSMPBF.PrimitiveGroup)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct PrimitiveGroup {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveGroup.nodes)
    pub nodes: ::std::vec::Vec<Node>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveGroup.dense)
    pub dense: ::protobuf::MessageField<DenseNodes>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveGroup.ways)
    pub ways: ::std::vec::Vec<Way>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveGroup.relations)
    pub relations: ::std::vec::Vec<Relation>,
    // @@protoc_insertion_point(field:OSMPBF.PrimitiveGroup.changesets)
    pub changesets: ::std::vec::Vec<ChangeSet>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.PrimitiveGroup.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a PrimitiveGroup {
    fn default() -> &'a PrimitiveGroup {
        <PrimitiveGroup as ::protobuf::Message>::default_instance()
    }
}

impl PrimitiveGroup {
    pub fn new() -> PrimitiveGroup {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for PrimitiveGroup {
    const NAME: &'static str = "PrimitiveGroup";

    fn is_initialized(&self) -> bool {
        for v in &self.nodes {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.dense {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.ways {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.relations {
            if !v.is_initialized() {
                return false;
            }
        };
        for v in &self.changesets {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.nodes.push(is.read_message()?);
                },
                18 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.dense)?;
                },
                26 => {
                    self.ways.push(is.read_message()?);
                },
                34 => {
                    self.relations.push(is.read_message()?);
                },
                42 => {
                    self.changesets.push(is.read_message()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.nodes {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        if let Some(v) = self.dense.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        for value in &self.ways {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.relations {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        for value in &self.changesets {
            let len = value.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.nodes {
            ::protobuf::rt::write_message_field_with_cached_size(1, v, os)?;
        };
        if let Some(v) = self.dense.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        for v in &self.ways {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        };
        for v in &self.relations {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        };
        for v in &self.changesets {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> PrimitiveGroup {
        PrimitiveGroup::new()
    }

    fn clear(&mut self) {
        self.nodes.clear();
        self.dense.clear();
        self.ways.clear();
        self.relations.clear();
        self.changesets.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static PrimitiveGroup {
        static instance: PrimitiveGroup = PrimitiveGroup {
            nodes: ::std::vec::Vec::new(),
            dense: ::protobuf::MessageField::none(),
            ways: ::std::vec::Vec::new(),
            relations: ::std::vec::Vec::new(),
            changesets: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// * String table, contains the common strings in each block.
///
/// Note that we reserve index '0' as a delimiter, so the entry at that
/// index in the table is ALWAYS blank and unused.
///
// @@protoc_insertion_point(message:OSMPBF.StringTable)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct StringTable {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.StringTable.s)
    pub s: ::std::vec::Vec<::std::vec::Vec<u8>>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.StringTable.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a StringTable {
    fn default() -> &'a StringTable {
        <StringTable as ::protobuf::Message>::default_instance()
    }
}

impl StringTable {
    pub fn new() -> StringTable {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for StringTable {
    const NAME: &'static str = "StringTable";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    self.s.push(is.read_bytes()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        for value in &self.s {
            my_size += ::protobuf::rt::bytes_size(1, &value);
        };
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        for v in &self.s {
            os.write_bytes(1, &v)?;
        };
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> StringTable {
        StringTable::new()
    }

    fn clear(&mut self) {
        self.s.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static StringTable {
        static instance: StringTable = StringTable {
            s: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

///  Optional metadata that may be included into each primitive. 
// @@protoc_insertion_point(message:OSMPBF.Info)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Info {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.Info.version)
    pub version: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:OSMPBF.Info.timestamp)
    pub timestamp: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.Info.changeset)
    pub changeset: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.Info.uid)
    pub uid: ::std::option::Option<i32>,
    // @@protoc_insertion_point(field:OSMPBF.Info.user_sid)
    pub user_sid: ::std::option::Option<u32>,
    ///  The visible flag is used to store history information. It indicates that
    ///  the current object version has been created by a delete operation on the
    ///  OSM API.
    ///  When a writer sets this flag, it MUST add a required_features tag with
    ///  value "HistoricalInformation" to the HeaderBlock.
    ///  If this flag is not available for some object it MUST be assumed to be
    ///  true if the file has the required_features tag "HistoricalInformation"
    ///  set.
    // @@protoc_insertion_point(field:OSMPBF.Info.visible)
    pub visible: ::std::option::Option<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.Info.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Info {
    fn default() -> &'a Info {
        <Info as ::protobuf::Message>::default_instance()
    }
}

impl Info {
    pub fn new() -> Info {
        ::std::default::Default::default()
    }

    // optional int32 version = 1;

    pub fn version(&self) -> i32 {
        self.version.unwrap_or(-1i32)
    }

    pub fn clear_version(&mut self) {
        self.version = ::std::option::Option::None;
    }

    pub fn has_version(&self) -> bool {
        self.version.is_some()
    }

    // Param is passed by value, moved
    pub fn set_version(&mut self, v: i32) {
        self.version = ::std::option::Option::Some(v);
    }

    // optional int64 timestamp = 2;

    pub fn timestamp(&self) -> i64 {
        self.timestamp.unwrap_or(0)
    }

    pub fn clear_timestamp(&mut self) {
        self.timestamp = ::std::option::Option::None;
    }

    pub fn has_timestamp(&self) -> bool {
        self.timestamp.is_some()
    }

    // Param is passed by value, moved
    pub fn set_timestamp(&mut self, v: i64) {
        self.timestamp = ::std::option::Option::Some(v);
    }

    // optional int64 changeset = 3;

    pub fn changeset(&self) -> i64 {
        self.changeset.unwrap_or(0)
    }

    pub fn clear_changeset(&mut self) {
        self.changeset = ::std::option::Option::None;
    }

    pub fn has_changeset(&self) -> bool {
        self.changeset.is_some()
    }

    // Param is passed by value, moved
    pub fn set_changeset(&mut self, v: i64) {
        self.changeset = ::std::option::Option::Some(v);
    }

    // optional int32 uid = 4;

    pub fn uid(&self) -> i32 {
        self.uid.unwrap_or(0)
    }

    pub fn clear_uid(&mut self) {
        self.uid = ::std::option::Option::None;
    }

    pub fn has_uid(&self) -> bool {
        self.uid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_uid(&mut self, v: i32) {
        self.uid = ::std::option::Option::Some(v);
    }

    // optional uint32 user_sid = 5;

    pub fn user_sid(&self) -> u32 {
        self.user_sid.unwrap_or(0)
    }

    pub fn clear_user_sid(&mut self) {
        self.user_sid = ::std::option::Option::None;
    }

    pub fn has_user_sid(&self) -> bool {
        self.user_sid.is_some()
    }

    // Param is passed by value, moved
    pub fn set_user_sid(&mut self, v: u32) {
        self.user_sid = ::std::option::Option::Some(v);
    }

    // optional bool visible = 6;

    pub fn visible(&self) -> bool {
        self.visible.unwrap_or(false)
    }

    pub fn clear_visible(&mut self) {
        self.visible = ::std::option::Option::None;
    }

    pub fn has_visible(&self) -> bool {
        self.visible.is_some()
    }

    // Param is passed by value, moved
    pub fn set_visible(&mut self, v: bool) {
        self.visible = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for Info {
    const NAME: &'static str = "Info";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.version = ::std::option::Option::Some(is.read_int32()?);
                },
                16 => {
                    self.timestamp = ::std::option::Option::Some(is.read_int64()?);
                },
                24 => {
                    self.changeset = ::std::option::Option::Some(is.read_int64()?);
                },
                32 => {
                    self.uid = ::std::option::Option::Some(is.read_int32()?);
                },
                40 => {
                    self.user_sid = ::std::option::Option::Some(is.read_uint32()?);
                },
                48 => {
                    self.visible = ::std::option::Option::Some(is.read_bool()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.version {
            my_size += ::protobuf::rt::int32_size(1, v);
        }
        if let Some(v) = self.timestamp {
            my_size += ::protobuf::rt::int64_size(2, v);
        }
        if let Some(v) = self.changeset {
            my_size += ::protobuf::rt::int64_size(3, v);
        }
        if let Some(v) = self.uid {
            my_size += ::protobuf::rt::int32_size(4, v);
        }
        if let Some(v) = self.user_sid {
            my_size += ::protobuf::rt::uint32_size(5, v);
        }
        if let Some(v) = self.visible {
            my_size += 1 + 1;
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.version {
            os.write_int32(1, v)?;
        }
        if let Some(v) = self.timestamp {
            os.write_int64(2, v)?;
        }
        if let Some(v) = self.changeset {
            os.write_int64(3, v)?;
        }
        if let Some(v) = self.uid {
            os.write_int32(4, v)?;
        }
        if let Some(v) = self.user_sid {
            os.write_uint32(5, v)?;
        }
        if let Some(v) = self.visible {
            os.write_bool(6, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Info {
        Info::new()
    }

    fn clear(&mut self) {
        self.version = ::std::option::Option::None;
        self.timestamp = ::std::option::Option::None;
        self.changeset = ::std::option::Option::None;
        self.uid = ::std::option::Option::None;
        self.user_sid = ::std::option::Option::None;
        self.visible = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Info {
        static instance: Info = Info {
            version: ::std::option::Option::None,
            timestamp: ::std::option::Option::None,
            changeset: ::std::option::Option::None,
            uid: ::std::option::Option::None,
            user_sid: ::std::option::Option::None,
            visible: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// * Optional metadata that may be included into each primitive. Special dense format used in DenseNodes. 
// @@protoc_insertion_point(message:OSMPBF.DenseInfo)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DenseInfo {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.version)
    pub version: ::std::vec::Vec<i32>,
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.timestamp)
    pub timestamp: ::std::vec::Vec<i64>,
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.changeset)
    pub changeset: ::std::vec::Vec<i64>,
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.uid)
    pub uid: ::std::vec::Vec<i32>,
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.user_sid)
    pub user_sid: ::std::vec::Vec<i32>,
    ///  The visible flag is used to store history information. It indicates that
    ///  the current object version has been created by a delete operation on the
    ///  OSM API.
    ///  When a writer sets this flag, it MUST add a required_features tag with
    ///  value "HistoricalInformation" to the HeaderBlock.
    ///  If this flag is not available for some object it MUST be assumed to be
    ///  true if the file has the required_features tag "HistoricalInformation"
    ///  set.
    // @@protoc_insertion_point(field:OSMPBF.DenseInfo.visible)
    pub visible: ::std::vec::Vec<bool>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.DenseInfo.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a DenseInfo {
    fn default() -> &'a DenseInfo {
        <DenseInfo as ::protobuf::Message>::default_instance()
    }
}

impl DenseInfo {
    pub fn new() -> DenseInfo {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for DenseInfo {
    const NAME: &'static str = "DenseInfo";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    is.read_repeated_packed_int32_into(&mut self.version)?;
                },
                8 => {
                    self.version.push(is.read_int32()?);
                },
                18 => {
                    is.read_repeated_packed_sint64_into(&mut self.timestamp)?;
                },
                16 => {
                    self.timestamp.push(is.read_sint64()?);
                },
                26 => {
                    is.read_repeated_packed_sint64_into(&mut self.changeset)?;
                },
                24 => {
                    self.changeset.push(is.read_sint64()?);
                },
                34 => {
                    is.read_repeated_packed_sint32_into(&mut self.uid)?;
                },
                32 => {
                    self.uid.push(is.read_sint32()?);
                },
                42 => {
                    is.read_repeated_packed_sint32_into(&mut self.user_sid)?;
                },
                40 => {
                    self.user_sid.push(is.read_sint32()?);
                },
                50 => {
                    is.read_repeated_packed_bool_into(&mut self.visible)?;
                },
                48 => {
                    self.visible.push(is.read_bool()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::vec_packed_int32_size(1, &self.version);
        my_size += ::protobuf::rt::vec_packed_sint64_size(2, &self.timestamp);
        my_size += ::protobuf::rt::vec_packed_sint64_size(3, &self.changeset);
        my_size += ::protobuf::rt::vec_packed_sint32_size(4, &self.uid);
        my_size += ::protobuf::rt::vec_packed_sint32_size(5, &self.user_sid);
        my_size += ::protobuf::rt::vec_packed_bool_size(6, &self.visible);
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        os.write_repeated_packed_int32(1, &self.version)?;
        os.write_repeated_packed_sint64(2, &self.timestamp)?;
        os.write_repeated_packed_sint64(3, &self.changeset)?;
        os.write_repeated_packed_sint32(4, &self.uid)?;
        os.write_repeated_packed_sint32(5, &self.user_sid)?;
        os.write_repeated_packed_bool(6, &self.visible)?;
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> DenseInfo {
        DenseInfo::new()
    }

    fn clear(&mut self) {
        self.version.clear();
        self.timestamp.clear();
        self.changeset.clear();
        self.uid.clear();
        self.user_sid.clear();
        self.visible.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DenseInfo {
        static instance: DenseInfo = DenseInfo {
            version: ::std::vec::Vec::new(),
            timestamp: ::std::vec::Vec::new(),
            changeset: ::std::vec::Vec::new(),
            uid: ::std::vec::Vec::new(),
            user_sid: ::std::vec::Vec::new(),
            visible: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

///  THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
///  TODO:    REMOVE THIS?
// @@protoc_insertion_point(message:OSMPBF.ChangeSet)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct ChangeSet {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.ChangeSet.id)
    pub id: ::std::option::Option<i64>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.ChangeSet.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a ChangeSet {
    fn default() -> &'a ChangeSet {
        <ChangeSet as ::protobuf::Message>::default_instance()
    }
}

impl ChangeSet {
    pub fn new() -> ChangeSet {
        ::std::default::Default::default()
    }

    // required int64 id = 1;

    pub fn id(&self) -> i64 {
        self.id.unwrap_or(0)
    }

    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for ChangeSet {
    const NAME: &'static str = "ChangeSet";

    fn is_initialized(&self) -> bool {
        if self.id.is_none() {
            return false;
        }
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = ::std::option::Option::Some(is.read_int64()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::int64_size(1, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.id {
            os.write_int64(1, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> ChangeSet {
        ChangeSet::new()
    }

    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static ChangeSet {
        static instance: ChangeSet = ChangeSet {
            id: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.Node)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Node {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.Node.id)
    pub id: ::std::option::Option<i64>,
    ///  Parallel arrays.
    // @@protoc_insertion_point(field:OSMPBF.Node.keys)
    pub keys: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Node.vals)
    pub vals: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Node.info)
    pub info: ::protobuf::MessageField<Info>,
    // @@protoc_insertion_point(field:OSMPBF.Node.lat)
    pub lat: ::std::option::Option<i64>,
    // @@protoc_insertion_point(field:OSMPBF.Node.lon)
    pub lon: ::std::option::Option<i64>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.Node.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Node {
    fn default() -> &'a Node {
        <Node as ::protobuf::Message>::default_instance()
    }
}

impl Node {
    pub fn new() -> Node {
        ::std::default::Default::default()
    }

    // required sint64 id = 1;

    pub fn id(&self) -> i64 {
        self.id.unwrap_or(0)
    }

    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = ::std::option::Option::Some(v);
    }

    // required sint64 lat = 8;

    pub fn lat(&self) -> i64 {
        self.lat.unwrap_or(0)
    }

    pub fn clear_lat(&mut self) {
        self.lat = ::std::option::Option::None;
    }

    pub fn has_lat(&self) -> bool {
        self.lat.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lat(&mut self, v: i64) {
        self.lat = ::std::option::Option::Some(v);
    }

    // required sint64 lon = 9;

    pub fn lon(&self) -> i64 {
        self.lon.unwrap_or(0)
    }

    pub fn clear_lon(&mut self) {
        self.lon = ::std::option::Option::None;
    }

    pub fn has_lon(&self) -> bool {
        self.lon.is_some()
    }

    // Param is passed by value, moved
    pub fn set_lon(&mut self, v: i64) {
        self.lon = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for Node {
    const NAME: &'static str = "Node";

    fn is_initialized(&self) -> bool {
        if self.id.is_none() {
            return false;
        }
        if self.lat.is_none() {
            return false;
        }
        if self.lon.is_none() {
            return false;
        }
        for v in &self.info {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = ::std::option::Option::Some(is.read_sint64()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.keys)?;
                },
                16 => {
                    self.keys.push(is.read_uint32()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.vals)?;
                },
                24 => {
                    self.vals.push(is.read_uint32()?);
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.info)?;
                },
                64 => {
                    self.lat = ::std::option::Option::Some(is.read_sint64()?);
                },
                72 => {
                    self.lon = ::std::option::Option::Some(is.read_sint64()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::sint64_size(1, v);
        }
        my_size += ::protobuf::rt::vec_packed_uint32_size(2, &self.keys);
        my_size += ::protobuf::rt::vec_packed_uint32_size(3, &self.vals);
        if let Some(v) = self.info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if let Some(v) = self.lat {
            my_size += ::protobuf::rt::sint64_size(8, v);
        }
        if let Some(v) = self.lon {
            my_size += ::protobuf::rt::sint64_size(9, v);
        }
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.id {
            os.write_sint64(1, v)?;
        }
        os.write_repeated_packed_uint32(2, &self.keys)?;
        os.write_repeated_packed_uint32(3, &self.vals)?;
        if let Some(v) = self.info.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        if let Some(v) = self.lat {
            os.write_sint64(8, v)?;
        }
        if let Some(v) = self.lon {
            os.write_sint64(9, v)?;
        }
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Node {
        Node::new()
    }

    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.keys.clear();
        self.vals.clear();
        self.info.clear();
        self.lat = ::std::option::Option::None;
        self.lon = ::std::option::Option::None;
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Node {
        static instance: Node = Node {
            id: ::std::option::Option::None,
            keys: ::std::vec::Vec::new(),
            vals: ::std::vec::Vec::new(),
            info: ::protobuf::MessageField::none(),
            lat: ::std::option::Option::None,
            lon: ::std::option::Option::None,
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.DenseNodes)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct DenseNodes {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.DenseNodes.id)
    pub id: ::std::vec::Vec<i64>,
    /// repeated Info info = 4;
    // @@protoc_insertion_point(field:OSMPBF.DenseNodes.denseinfo)
    pub denseinfo: ::protobuf::MessageField<DenseInfo>,
    // @@protoc_insertion_point(field:OSMPBF.DenseNodes.lat)
    pub lat: ::std::vec::Vec<i64>,
    // @@protoc_insertion_point(field:OSMPBF.DenseNodes.lon)
    pub lon: ::std::vec::Vec<i64>,
    ///  Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
    // @@protoc_insertion_point(field:OSMPBF.DenseNodes.keys_vals)
    pub keys_vals: ::std::vec::Vec<i32>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.DenseNodes.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a DenseNodes {
    fn default() -> &'a DenseNodes {
        <DenseNodes as ::protobuf::Message>::default_instance()
    }
}

impl DenseNodes {
    pub fn new() -> DenseNodes {
        ::std::default::Default::default()
    }
}

impl ::protobuf::Message for DenseNodes {
    const NAME: &'static str = "DenseNodes";

    fn is_initialized(&self) -> bool {
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                10 => {
                    is.read_repeated_packed_sint64_into(&mut self.id)?;
                },
                8 => {
                    self.id.push(is.read_sint64()?);
                },
                42 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.denseinfo)?;
                },
                66 => {
                    is.read_repeated_packed_sint64_into(&mut self.lat)?;
                },
                64 => {
                    self.lat.push(is.read_sint64()?);
                },
                74 => {
                    is.read_repeated_packed_sint64_into(&mut self.lon)?;
                },
                72 => {
                    self.lon.push(is.read_sint64()?);
                },
                82 => {
                    is.read_repeated_packed_int32_into(&mut self.keys_vals)?;
                },
                80 => {
                    self.keys_vals.push(is.read_int32()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        my_size += ::protobuf::rt::vec_packed_sint64_size(1, &self.id);
        if let Some(v) = self.denseinfo.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::vec_packed_sint64_size(8, &self.lat);
        my_size += ::protobuf::rt::vec_packed_sint64_size(9, &self.lon);
        my_size += ::protobuf::rt::vec_packed_int32_size(10, &self.keys_vals);
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        os.write_repeated_packed_sint64(1, &self.id)?;
        if let Some(v) = self.denseinfo.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
        }
        os.write_repeated_packed_sint64(8, &self.lat)?;
        os.write_repeated_packed_sint64(9, &self.lon)?;
        os.write_repeated_packed_int32(10, &self.keys_vals)?;
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> DenseNodes {
        DenseNodes::new()
    }

    fn clear(&mut self) {
        self.id.clear();
        self.denseinfo.clear();
        self.lat.clear();
        self.lon.clear();
        self.keys_vals.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static DenseNodes {
        static instance: DenseNodes = DenseNodes {
            id: ::std::vec::Vec::new(),
            denseinfo: ::protobuf::MessageField::none(),
            lat: ::std::vec::Vec::new(),
            lon: ::std::vec::Vec::new(),
            keys_vals: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.Way)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Way {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.Way.id)
    pub id: ::std::option::Option<i64>,
    ///  Parallel arrays.
    // @@protoc_insertion_point(field:OSMPBF.Way.keys)
    pub keys: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Way.vals)
    pub vals: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Way.info)
    pub info: ::protobuf::MessageField<Info>,
    // @@protoc_insertion_point(field:OSMPBF.Way.refs)
    pub refs: ::std::vec::Vec<i64>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.Way.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Way {
    fn default() -> &'a Way {
        <Way as ::protobuf::Message>::default_instance()
    }
}

impl Way {
    pub fn new() -> Way {
        ::std::default::Default::default()
    }

    // required int64 id = 1;

    pub fn id(&self) -> i64 {
        self.id.unwrap_or(0)
    }

    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for Way {
    const NAME: &'static str = "Way";

    fn is_initialized(&self) -> bool {
        if self.id.is_none() {
            return false;
        }
        for v in &self.info {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = ::std::option::Option::Some(is.read_int64()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.keys)?;
                },
                16 => {
                    self.keys.push(is.read_uint32()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.vals)?;
                },
                24 => {
                    self.vals.push(is.read_uint32()?);
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.info)?;
                },
                66 => {
                    is.read_repeated_packed_sint64_into(&mut self.refs)?;
                },
                64 => {
                    self.refs.push(is.read_sint64()?);
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::int64_size(1, v);
        }
        my_size += ::protobuf::rt::vec_packed_uint32_size(2, &self.keys);
        my_size += ::protobuf::rt::vec_packed_uint32_size(3, &self.vals);
        if let Some(v) = self.info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::vec_packed_sint64_size(8, &self.refs);
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.id {
            os.write_int64(1, v)?;
        }
        os.write_repeated_packed_uint32(2, &self.keys)?;
        os.write_repeated_packed_uint32(3, &self.vals)?;
        if let Some(v) = self.info.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        os.write_repeated_packed_sint64(8, &self.refs)?;
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Way {
        Way::new()
    }

    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.keys.clear();
        self.vals.clear();
        self.info.clear();
        self.refs.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Way {
        static instance: Way = Way {
            id: ::std::option::Option::None,
            keys: ::std::vec::Vec::new(),
            vals: ::std::vec::Vec::new(),
            info: ::protobuf::MessageField::none(),
            refs: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

// @@protoc_insertion_point(message:OSMPBF.Relation)
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Relation {
    // message fields
    // @@protoc_insertion_point(field:OSMPBF.Relation.id)
    pub id: ::std::option::Option<i64>,
    ///  Parallel arrays.
    // @@protoc_insertion_point(field:OSMPBF.Relation.keys)
    pub keys: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Relation.vals)
    pub vals: ::std::vec::Vec<u32>,
    // @@protoc_insertion_point(field:OSMPBF.Relation.info)
    pub info: ::protobuf::MessageField<Info>,
    ///  Parallel arrays
    // @@protoc_insertion_point(field:OSMPBF.Relation.roles_sid)
    pub roles_sid: ::std::vec::Vec<i32>,
    // @@protoc_insertion_point(field:OSMPBF.Relation.memids)
    pub memids: ::std::vec::Vec<i64>,
    // @@protoc_insertion_point(field:OSMPBF.Relation.types)
    pub types: ::std::vec::Vec<::protobuf::EnumOrUnknown<relation::MemberType>>,
    // special fields
    // @@protoc_insertion_point(special_field:OSMPBF.Relation.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

impl<'a> ::std::default::Default for &'a Relation {
    fn default() -> &'a Relation {
        <Relation as ::protobuf::Message>::default_instance()
    }
}

impl Relation {
    pub fn new() -> Relation {
        ::std::default::Default::default()
    }

    // required int64 id = 1;

    pub fn id(&self) -> i64 {
        self.id.unwrap_or(0)
    }

    pub fn clear_id(&mut self) {
        self.id = ::std::option::Option::None;
    }

    pub fn has_id(&self) -> bool {
        self.id.is_some()
    }

    // Param is passed by value, moved
    pub fn set_id(&mut self, v: i64) {
        self.id = ::std::option::Option::Some(v);
    }
}

impl ::protobuf::Message for Relation {
    const NAME: &'static str = "Relation";

    fn is_initialized(&self) -> bool {
        if self.id.is_none() {
            return false;
        }
        for v in &self.info {
            if !v.is_initialized() {
                return false;
            }
        };
        true
    }

    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
        while let Some(tag) = is.read_raw_tag_or_eof()? {
            match tag {
                8 => {
                    self.id = ::std::option::Option::Some(is.read_int64()?);
                },
                18 => {
                    is.read_repeated_packed_uint32_into(&mut self.keys)?;
                },
                16 => {
                    self.keys.push(is.read_uint32()?);
                },
                26 => {
                    is.read_repeated_packed_uint32_into(&mut self.vals)?;
                },
                24 => {
                    self.vals.push(is.read_uint32()?);
                },
                34 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.info)?;
                },
                66 => {
                    is.read_repeated_packed_int32_into(&mut self.roles_sid)?;
                },
                64 => {
                    self.roles_sid.push(is.read_int32()?);
                },
                74 => {
                    is.read_repeated_packed_sint64_into(&mut self.memids)?;
                },
                72 => {
                    self.memids.push(is.read_sint64()?);
                },
                80 => {
                    self.types.push(is.read_enum_or_unknown()?);
                },
                82 => {
                    ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.types)?
                },
                tag => {
                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                },
            };
        }
        ::std::result::Result::Ok(())
    }

    // Compute sizes of nested messages
    #[allow(unused_variables)]
    fn compute_size(&self) -> u64 {
        let mut my_size = 0;
        if let Some(v) = self.id {
            my_size += ::protobuf::rt::int64_size(1, v);
        }
        my_size += ::protobuf::rt::vec_packed_uint32_size(2, &self.keys);
        my_size += ::protobuf::rt::vec_packed_uint32_size(3, &self.vals);
        if let Some(v) = self.info.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        my_size += ::protobuf::rt::vec_packed_int32_size(8, &self.roles_sid);
        my_size += ::protobuf::rt::vec_packed_sint64_size(9, &self.memids);
        my_size += ::protobuf::rt::vec_packed_enum_or_unknown_size(10, &self.types);
        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
        self.special_fields.cached_size().set(my_size as u32);
        my_size
    }

    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
        if let Some(v) = self.id {
            os.write_int64(1, v)?;
        }
        os.write_repeated_packed_uint32(2, &self.keys)?;
        os.write_repeated_packed_uint32(3, &self.vals)?;
        if let Some(v) = self.info.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?;
        }
        os.write_repeated_packed_int32(8, &self.roles_sid)?;
        os.write_repeated_packed_sint64(9, &self.memids)?;
        os.write_repeated_packed_enum_or_unknown(10, &self.types)?;
        os.write_unknown_fields(self.special_fields.unknown_fields())?;
        ::std::result::Result::Ok(())
    }

    fn special_fields(&self) -> &::protobuf::SpecialFields {
        &self.special_fields
    }

    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
        &mut self.special_fields
    }

    fn new() -> Relation {
        Relation::new()
    }

    fn clear(&mut self) {
        self.id = ::std::option::Option::None;
        self.keys.clear();
        self.vals.clear();
        self.info.clear();
        self.roles_sid.clear();
        self.memids.clear();
        self.types.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static Relation {
        static instance: Relation = Relation {
            id: ::std::option::Option::None,
            keys: ::std::vec::Vec::new(),
            vals: ::std::vec::Vec::new(),
            info: ::protobuf::MessageField::none(),
            roles_sid: ::std::vec::Vec::new(),
            memids: ::std::vec::Vec::new(),
            types: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

/// Nested message and enums of message `Relation`
pub mod relation {
    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
    // @@protoc_insertion_point(enum:OSMPBF.Relation.MemberType)
    pub enum MemberType {
        // @@protoc_insertion_point(enum_value:OSMPBF.Relation.MemberType.NODE)
        NODE = 0,
        // @@protoc_insertion_point(enum_value:OSMPBF.Relation.MemberType.WAY)
        WAY = 1,
        // @@protoc_insertion_point(enum_value:OSMPBF.Relation.MemberType.RELATION)
        RELATION = 2,
    }

    impl ::protobuf::Enum for MemberType {
        const NAME: &'static str = "MemberType";

        fn value(&self) -> i32 {
            *self as i32
        }

        fn from_i32(value: i32) -> ::std::option::Option<MemberType> {
            match value {
                0 => ::std::option::Option::Some(MemberType::NODE),
                1 => ::std::option::Option::Some(MemberType::WAY),
                2 => ::std::option::Option::Some(MemberType::RELATION),
                _ => ::std::option::Option::None
            }
        }

        fn from_str(str: &str) -> ::std::option::Option<MemberType> {
            match str {
                "NODE" => ::std::option::Option::Some(MemberType::NODE),
                "WAY" => ::std::option::Option::Some(MemberType::WAY),
                "RELATION" => ::std::option::Option::Some(MemberType::RELATION),
                _ => ::std::option::Option::None
            }
        }

        const VALUES: &'static [MemberType] = &[
            MemberType::NODE,
            MemberType::WAY,
            MemberType::RELATION,
        ];
    }

    impl ::std::default::Default for MemberType {
        fn default() -> Self {
            MemberType::NODE
        }
    }

}