Various small cleanups based on clang-tidy findings

Author: joto

include/osmium/diff_handler.hpp

@@ -48,13 +48,13 @@ namespace osmium {
 
             DiffHandler() = default;
 
-            void node(const osmium::DiffNode&) const noexcept {
+            void node(const osmium::DiffNode& /*node*/) const noexcept {
             }
 
-            void way(const osmium::DiffWay&) const noexcept {
+            void way(const osmium::DiffWay& /*way*/) const noexcept {
             }
 
-            void relation(const osmium::DiffRelation&) const noexcept {
+            void relation(const osmium::DiffRelation& /*relation*/) const noexcept {
             }
 
         }; // class DiffHandler

include/osmium/diff_iterator.hpp

@@ -91,8 +91,7 @@ namespace osmium {
             m_prev(begin),
             m_curr(begin),
             m_next(begin == end ? begin : ++begin),
-            m_end(std::move(end)),
-            m_diff() {
+            m_end(std::move(end)) {
         }
 
         DiffIterator& operator++() {

include/osmium/experimental/flex_reader.hpp

@@ -73,7 +73,6 @@ namespace osmium {
                 m_entities((entities & ~osmium::osm_entity_bits::area) | (m_with_areas ? osmium::osm_entity_bits::node | osmium::osm_entity_bits::way : osmium::osm_entity_bits::nothing)),
                 m_location_handler(location_handler),
                 m_reader(file, m_entities),
-                m_assembler_config(),
                 m_collector(m_assembler_config)
             {
                 m_location_handler.ignore_errors();

include/osmium/handler/chain.hpp

@@ -80,7 +80,7 @@ namespace osmium {
 
             template <int SIZE, typename THandlers>
             struct call_flush<SIZE, SIZE, THandlers> {
-                void operator()(THandlers&) {}
+                void operator()(THandlers& /*handlers*/) {}
             }; // struct call_flush
 
             OSMIUM_CHAIN_HANDLER_CALL(node, Node)

include/osmium/index/multimap/hybrid.hpp

@@ -106,9 +106,8 @@ namespace osmium {
                 const element_type& operator*() {
                     if (m_begin_main == m_end_main) {
                         return *m_begin_extra;
-                    } else {
-                        return *m_begin_main;
                     }
+                    return *m_begin_main;
                 }
 
                 const element_type* operator->() {

include/osmium/index/multimap/sparse_mem_multimap.hpp

@@ -60,7 +60,7 @@ namespace osmium {
                 // and parent plus some overhead for color of red-black-tree
                 // or similar).
                 enum {
-                    element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4u
+                    element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4U
                 };
 
             public:

include/osmium/util/verbose_output.hpp

@@ -61,21 +61,21 @@ namespace osmium {
         class VerboseOutput {
 
             /// all time output will be relative to this start time
-            time_t m_start;
+            std::time_t m_start;
 
             /// is verbose mode enabled?
             bool m_verbose;
 
             /// a newline was written, start next output with runtime
-            bool m_newline;
+            bool m_newline = true;
 
             /**
              * If we remember that a newline was written as the last thing
              * write out the time elapsed and reset the newline flag.
              */
             void start_line() {
                 if (m_newline) {
-                    const time_t elapsed = runtime();
+                    const std::time_t elapsed = runtime();
 
                     const char old_fill = std::cerr.fill();
                     std::cerr << '[' << std::setw(2) << (elapsed / 60) << ':' << std::setw(2) << std::setfill('0') << (elapsed % 60) << "] ";
@@ -88,13 +88,12 @@ namespace osmium {
         public:
 
             explicit VerboseOutput(bool verbose = false) noexcept :
-                m_start(time(nullptr)),
-                m_verbose(verbose),
-                m_newline(true) {
+                m_start(std::time(nullptr)),
+                m_verbose(verbose) {
             }
 
-            time_t runtime() const noexcept {
-                return time(nullptr) - m_start;
+            std::time_t runtime() const noexcept {
+                return std::time(nullptr) - m_start;
             }
 
             /// Get "verbose" setting.