Derive Clone, Debug for public types

src/blob.rs

 
 
 /// The content type of a blob.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum BlobType<'a> {
     /// Blob contains a `HeaderBlock`.
     OsmHeader,
 
 //TODO rename variants to fit proto files
 /// The decoded content of a blob (analogous to `BlobType`).
+#[derive(Clone, Debug)]
 pub enum BlobDecode<'a> {
     /// Blob contains a `HeaderBlock`.
     OsmHeader(Box<HeaderBlock>),
 ///
 /// A PBF file consists of a sequence of blobs. This type supports decoding the content of a blob
 /// to different types of blocks that are usually more interesting to the user.
+#[derive(Clone, Debug)]
 pub struct Blob {
     header: fileformat::BlobHeader,
     blob: fileformat::Blob,
 }
 
 /// A reader for PBF files that allows iterating over `Blob`s.
+#[derive(Clone, Debug)]
 pub struct BlobReader<R: Read> {
     reader: R,
     last_blob_ok: bool,

src/block.rs

 
 
 /// A `HeaderBlock`. It contains metadata about following `PrimitiveBlock`s.
+#[derive(Clone, Debug)]
 pub struct HeaderBlock {
     header: osmformat::HeaderBlock,
 }
 }
 
 /// A `PrimitiveBlock`. It contains a sequence of groups.
+#[derive(Clone, Debug)]
 pub struct PrimitiveBlock {
     block: osmformat::PrimitiveBlock,
 }
 }
 
 /// A `PrimitiveGroup` contains a sequence of elements of one type.
+#[derive(Clone, Debug)]
 pub struct PrimitiveGroup<'a> {
     block: &'a osmformat::PrimitiveBlock,
     group: &'a osmformat::PrimitiveGroup,
 }
 
 /// An iterator over the groups in a `PrimitiveBlock`.
+#[derive(Clone, Debug)]
 pub struct GroupIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     groups: std::slice::Iter<'a, osmformat::PrimitiveGroup>,
 impl<'a> ExactSizeIterator for GroupIter<'a> {}
 
 /// An iterator over the nodes in a `PrimitiveGroup`.
+#[derive(Clone, Debug)]
 pub struct GroupNodeIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     nodes: std::slice::Iter<'a, osmformat::Node>,
 impl<'a> ExactSizeIterator for GroupNodeIter<'a> {}
 
 /// An iterator over the ways in a `PrimitiveGroup`.
+#[derive(Clone, Debug)]
 pub struct GroupWayIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     ways: std::slice::Iter<'a, osmformat::Way>,
 impl<'a> ExactSizeIterator for GroupWayIter<'a> {}
 
 /// An iterator over the relations in a `PrimitiveGroup`.
+#[derive(Clone, Debug)]
 pub struct GroupRelationIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     rels: std::slice::Iter<'a, osmformat::Relation>,

src/dense.rs

 
 //TODO Add getter functions for id, version, uid, ...
 /// An OpenStreetMap node element from a compressed array of dense nodes (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Node)).
+#[derive(Clone, Debug)]
 pub struct DenseNode<'a> {
     block: &'a osmformat::PrimitiveBlock,
 
 }
 
 /// An iterator over dense nodes. It decodes the delta encoded values.
+#[derive(Clone, Debug)]
 pub struct DenseNodeIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     dids: std::slice::Iter<'a, i64>, // deltas
 impl<'a> ExactSizeIterator for DenseNodeIter<'a> {}
 
 /// An iterator over the tags in a dense node.
+#[derive(Clone, Debug)]
 pub struct DenseTagIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     keys_vals_indices: std::slice::Iter<'a, i32>,

src/elements.rs

 
 
 /// An OpenStreetMap node element (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Node)).
+#[derive(Clone, Debug)]
 pub struct Node<'a> {
     block: &'a PrimitiveBlock,
     osmnode: &'a osmformat::Node,
 ///
 /// A way contains an ordered list of node references that can be accessed with the `refs` or the
 /// `refs_slice` method.
+#[derive(Clone, Debug)]
 pub struct Way<'a> {
     block: &'a PrimitiveBlock,
     osmway: &'a osmformat::Way,
 /// An OpenStreetMap relation element (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Relation)).
 ///
 /// A relation contains an ordered list of members that can be of any element type.
+#[derive(Clone, Debug)]
 pub struct Relation<'a> {
     block: &'a PrimitiveBlock,
     osmrel: &'a osmformat::Relation,
 /// An iterator over the references of a way.
 ///
 /// Each reference corresponds to a node id.
+#[derive(Clone, Debug)]
 pub struct WayRefIter<'a> {
     deltas: std::slice::Iter<'a, i64>,
     current: i64,
 impl<'a> ExactSizeIterator for WayRefIter<'a> {}
 
 /// The element type of a relation member.
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum RelMemberType {
     Node,
     Way,
 /// A member of a relation.
 ///
 /// Each member has a member type and a member id that references an element of that type.
+#[derive(Clone, Debug)]
 pub struct RelMember<'a> {
     block: &'a PrimitiveBlock,
     pub role_sid: i32,
 }
 
 /// An iterator over the members of a relation.
+#[derive(Clone, Debug)]
 pub struct RelMemberIter<'a> {
     block: &'a PrimitiveBlock,
     role_sids: std::slice::Iter<'a, i32>,
 impl<'a> ExactSizeIterator for RelMemberIter<'a> {}
 
 /// An iterator over the tags of an element.
+#[derive(Clone, Debug)]
 pub struct TagIter<'a> {
     block: &'a PrimitiveBlock,
     key_indices: std::slice::Iter<'a, u32>,
 impl<'a> ExactSizeIterator for TagIter<'a> {}
 
 /// Additional metadata that might be included in each element.
+#[derive(Clone, Debug)]
 pub struct Info<'a> {
     block: &'a PrimitiveBlock,
     info: &'a osmformat::Info,

src/mmap_blob.rs

 
 
 /// A read-only memory map.
+#[derive(Debug)]
 pub struct Mmap {
     mmap: memmap::Mmap,
 }
 }
 
 /// A PBF blob from a memory map.
+#[derive(Clone, Debug)]
 pub struct MmapBlob<'a> {
     header: BlobHeader,
     data: &'a [u8],
 }
 
 /// A reader for memory mapped PBF files that allows iterating over `MmapBlob`s.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct MmapBlobReader<'a> {
     mmap: &'a Mmap,
     offset: usize,

src/reader.rs

 
 
 /// A reader for PBF files that gives access to the stored elements: nodes, ways and relations.
+#[derive(Clone, Debug)]
 pub struct ElementReader<R: Read> {
     blob_iter: BlobReader<R>,
 }
 }
 
 /// An enum with the OSM core elements: nodes, ways and relations.
+#[derive(Clone, Debug)]
 pub enum Element<'a> {
     /// A node. Also, see `DenseNode`.
     Node(Node<'a>),