Use UPPERCASE for numerical constants

Author: joto

CONTRIBUTING.md

@@ -36,7 +36,7 @@ Code must be written in the
 always be used for code blocks, even one-liners.
 
 Names should use underscores, not camel case, with class/struct names ending in
-`_t`. Template parameters must use all upper case.
+`_t`. Constants and template parameters must use all upper case.
 
 Header files should be included in the following order, each group in their own
 block:

src/db-copy.cpp

@@ -100,7 +100,7 @@ void db_copy_thread_t::send_command(db_cmd_t &&buffer)
 
     std::unique_lock<std::mutex> lock{m_shared.queue_mutex};
     m_shared.queue_full_cond.wait(lock, [&] {
-        return m_shared.worker_queue.size() < db_cmd_copy_t::Max_buffers;
+        return m_shared.worker_queue.size() < db_cmd_copy_t::MAX_BUFFERS;
     });
 
     m_shared.worker_queue.push_back(std::move(buffer));

src/db-copy.hpp

@@ -79,7 +79,7 @@ class db_deleter_by_id_t
      * There is a trade-off here between sending as few DELETE SQL as
      * possible and keeping the size of the deletable vector managable.
      */
-    static constexpr std::size_t Max_entries = 1000000;
+    static constexpr std::size_t MAX_ENTRIES = 1000000;
 
 public:
     bool has_data() const noexcept { return !m_deletables.empty(); }
@@ -89,7 +89,7 @@ class db_deleter_by_id_t
     void delete_rows(std::string const &table, std::string const &column,
                      pg_conn_t const &db_connection);
 
-    bool is_full() const noexcept { return m_deletables.size() > Max_entries; }
+    bool is_full() const noexcept { return m_deletables.size() > MAX_ENTRIES; }
 
 private:
     /// Vector with object to delete before copying
@@ -105,7 +105,7 @@ class db_deleter_by_type_and_id_t
      * There is a trade-off here between sending as few DELETE SQL as
      * possible and keeping the size of the deletable vector managable.
      */
-    static constexpr std::size_t Max_entries = 1000000;
+    static constexpr std::size_t MAX_ENTRIES = 1000000;
 
     struct item_t
     {
@@ -129,7 +129,7 @@ class db_deleter_by_type_and_id_t
     void delete_rows(std::string const &table, std::string const &column,
                      pg_conn_t const &db_connection);
 
-    bool is_full() const noexcept { return m_deletables.size() > Max_entries; }
+    bool is_full() const noexcept { return m_deletables.size() > MAX_ENTRIES; }
 
 private:
     /// Vector with object to delete before copying
@@ -145,7 +145,7 @@ struct db_cmd_copy_t
      * to speed up processing. Currently a one-size fits all value.
      * Needs more testing and individual values per queue.
      */
-    static constexpr std::size_t Max_buf_size = 10 * 1024 * 1024;
+    static constexpr std::size_t MAX_BUF_SIZE = 10 * 1024 * 1024;
 
     /**
      * Maximum length of the queue with COPY data.
@@ -155,7 +155,7 @@ struct db_cmd_copy_t
      * be full and it is better to keep the queue smaller to reduce memory
      * usage. Current value is just assumed to be a reasonable trade off.
      */
-    static constexpr std::size_t Max_buffers = 10;
+    static constexpr std::size_t MAX_BUFFERS = 10;
 
     /// Name of the target table for the copy operation
     std::shared_ptr<db_target_descr_t> target;
@@ -167,7 +167,7 @@ struct db_cmd_copy_t
     explicit db_cmd_copy_t(std::shared_ptr<db_target_descr_t> t)
     : target(std::move(t))
     {
-        buffer.reserve(Max_buf_size);
+        buffer.reserve(MAX_BUF_SIZE);
     }
 
     explicit operator bool() const noexcept { return target != nullptr; }
@@ -182,7 +182,7 @@ class db_cmd_copy_delete_t : public db_cmd_copy_t
     /// Return true if the buffer is filled up.
     bool is_full() const noexcept
     {
-        return (buffer.size() > Max_buf_size - 100) || m_deleter.is_full();
+        return (buffer.size() > MAX_BUF_SIZE - 100) || m_deleter.is_full();
     }
 
     bool has_deletables() const noexcept { return m_deleter.has_data(); }

src/expire-tiles.cpp

@@ -63,8 +63,8 @@ geom::point_t expire_tiles::coords_to_tile(geom::point_t const &point)
 {
     auto const c = m_projection->target_to_tile(point);
 
-    return {m_map_width * (0.5 + c.x() / tile_t::earth_circumference),
-            m_map_width * (0.5 - c.y() / tile_t::earth_circumference)};
+    return {m_map_width * (0.5 + c.x() / tile_t::EARTH_CIRCUMFERENCE),
+            m_map_width * (0.5 - c.y() / tile_t::EARTH_CIRCUMFERENCE)};
 }
 
 void expire_tiles::from_point_list(geom::point_list_t const &list,
@@ -224,14 +224,14 @@ int expire_tiles::from_bbox(geom::box_t const &box,
 
     double const width = box.width();
     double const height = box.height();
-    if (width > tile_t::half_earth_circumference + 1) {
+    if (width > tile_t::HALF_EARTH_CIRCUMFERENCE + 1) {
         /* Over half the planet's width within the bounding box - assume the
            box crosses the international date line and split it into two boxes */
-        int ret = from_bbox({-tile_t::half_earth_circumference, box.min_y(),
+        int ret = from_bbox({-tile_t::HALF_EARTH_CIRCUMFERENCE, box.min_y(),
                              box.min_x(), box.max_y()},
                             expire_config);
         ret += from_bbox({box.max_x(), box.min_y(),
-                          tile_t::half_earth_circumference, box.max_y()},
+                          tile_t::HALF_EARTH_CIRCUMFERENCE, box.max_y()},
                          expire_config);
         return ret;
     }

src/gen/osm2pgsql-gen.cpp

@@ -76,7 +76,7 @@
 
 namespace {
 
-constexpr std::size_t const max_force_single_thread = 4;
+constexpr std::size_t const MAX_FORCE_SINGLE_THREAD = 4;
 
 struct tile_extent
 {
@@ -496,7 +496,7 @@ class genproc_t
             }
         }
         log_debug("Need to process {} tiles.", tile_list.size());
-        if (m_jobs == 1 || tile_list.size() < max_force_single_thread) {
+        if (m_jobs == 1 || tile_list.size() < MAX_FORCE_SINGLE_THREAD) {
             log_debug("Running in single-threaded mode.");
             tile_processor_t tp{generalizer, tile_list.size()};
             while (!tile_list.empty()) {

src/gen/tracer.cpp

@@ -42,7 +42,7 @@ tracer_t::trace(canvas_t const &canvas, tile_t const &tile, double min_area)
     prepare(canvas);
 
     potrace_bitmap_t const bitmap{int(canvas.size()), int(canvas.size()),
-                                  int(canvas.size() / bits_per_word),
+                                  int(canvas.size() / BITS_PER_WORD),
                                   m_bits.data()};
 
     std::unique_ptr<potrace_state_t, potrace_state_deleter> state{
@@ -64,9 +64,9 @@ void tracer_t::reset()
 void tracer_t::prepare(canvas_t const &canvas) noexcept
 {
     std::size_t const size = canvas.size();
-    assert(size % bits_per_word == 0);
+    assert(size % BITS_PER_WORD == 0);
 
-    m_bits.reserve((size * size) / bits_per_word);
+    m_bits.reserve((size * size) / BITS_PER_WORD);
 
     for (unsigned char const *d = canvas.begin(); d != canvas.end(); d += 8) {
         auto w = bit_squeeze(0, d);

src/gen/tracer.hpp

@@ -39,7 +39,7 @@ class tracer_t
     std::size_t num_points() const noexcept { return m_num_points; }
 
 private:
-    static constexpr auto const bits_per_word = sizeof(potrace_word) * 8;
+    static constexpr auto const BITS_PER_WORD = sizeof(potrace_word) * 8;
 
     geom::point_t make_point(potrace_dpoint_t const &p) const noexcept;
 

src/node-locations.cpp

@@ -64,7 +64,7 @@ osmium::Location node_locations_t::get(osmid_t id) const
     osmium::DeltaDecode<int64_t> dx;
     osmium::DeltaDecode<int64_t> dy;
 
-    for (std::size_t n = 0; n < block_size && begin != end; ++n) {
+    for (std::size_t n = 0; n < BLOCK_SIZE && begin != end; ++n) {
         auto const bid = did.update(
             static_cast<int64_t>(protozero::decode_varint(&begin, end)));
         auto const x = static_cast<int32_t>(dx.update(
@@ -83,13 +83,13 @@ osmium::Location node_locations_t::get(osmid_t id) const
 
 void node_locations_t::log_stats()
 {
-    constexpr auto const mbyte = 1024 * 1024;
+    constexpr auto const MBYTE = 1024 * 1024;
     log_debug("Node locations cache:");
     log_debug("  num locations stored: {}", m_count);
-    log_debug("  bytes overall: {}MB", used_memory() / mbyte);
-    log_debug("  data capacity: {}MB", m_data.capacity() / mbyte);
-    log_debug("  data size: {}MB", m_data.size() / mbyte);
-    log_debug("  index used memory: {}MB", m_index.used_memory() / mbyte);
+    log_debug("  bytes overall: {}MB", used_memory() / MBYTE);
+    log_debug("  data capacity: {}MB", m_data.capacity() / MBYTE);
+    log_debug("  data size: {}MB", m_data.size() / MBYTE);
+    log_debug("  index used memory: {}MB", m_index.used_memory() / MBYTE);
 }
 
 void node_locations_t::clear()

src/node-locations.hpp

@@ -81,9 +81,15 @@ class node_locations_t
     void clear();
 
 private:
+    /**
+     * The block size used for internal blocks. The larger the block size
+     * the less memory is consumed but the more expensive the access is.
+     */
+    static constexpr const std::size_t BLOCK_SIZE = 32;
+
     bool first_entry_in_block() const noexcept
     {
-        return m_count % block_size == 0;
+        return m_count % BLOCK_SIZE == 0;
     }
 
     /// The maximum number of bytes an entry will need in storage.
@@ -97,12 +103,6 @@ class node_locations_t
                (m_data.size() + max_bytes_per_entry() >= m_data.capacity());
     }
 
-    /**
-     * The block size used for internal blocks. The larger the block size
-     * the less memory is consumed but the more expensive the access is.
-     */
-    static constexpr const std::size_t block_size = 32;
-
     ordered_index_t m_index;
     std::string m_data;
 

src/ordered-index.cpp

@@ -26,7 +26,7 @@ void ordered_index_t::add(osmid_t id, std::size_t offset)
         }
         m_ranges.emplace_back(id, offset, m_block_size);
         m_capacity += m_block_size;
-        if (m_block_size < max_block_size) {
+        if (m_block_size < MAX_BLOCK_SIZE) {
             m_block_size <<= 1U;
         }
     }