fix some clang-tidy warnings

Author: jlblancoc

.clang-tidy

@@ -1,14 +1,14 @@
-Checks:
-  - "-*"
-  - "bugprone-*"
-  - "readability-braces-around-statements"
-  - "readability-else-after-return"
-  - "cppcoreguidelines-interfaces-global-init"
-  - "cppcoreguidelines-pro-type-member-init"
-  - "cppcoreguidelines-pro-type-static-cast-downcast"
-  - "cppcoreguidelines-pro-type-union-access"
-  - "cppcoreguidelines-slicing"
-  - "cppcoreguidelines-special-member-functions"
+Checks: >
+  -*,
+  bugprone-*,
+  readability-braces-around-statements,
+  readability-else-after-return,
+  cppcoreguidelines-interfaces-global-init,
+  cppcoreguidelines-pro-type-member-init,
+  cppcoreguidelines-pro-type-static-cast-downcast,
+  cppcoreguidelines-pro-type-union-access,
+  cppcoreguidelines-slicing,
+  cppcoreguidelines-special-member-functions
 WarningsAsErrors: ''
 HeaderFilterRegex: '.*'
 FormatStyle: file

modules/mrpt_containers/include/mrpt/containers/CDynamicGrid.h

@@ -112,7 +112,10 @@ class CDynamicGrid
    */
   inline void fill(const T& value)
   {
-    for (auto it = m_map.begin(); it != m_map.end(); ++it) *it = value;
+    for (auto it = m_map.begin(); it != m_map.end(); ++it)
+    {
+      *it = value;
+    }
   }
 
   /** Changes the size of the grid, maintaining previous contents.
@@ -133,30 +136,62 @@ class CDynamicGrid
       return;
     }
 
-    if (new_x_min > m_x_min) new_x_min = m_x_min;
-    if (new_x_max < m_x_max) new_x_max = m_x_max;
-    if (new_y_min > m_y_min) new_y_min = m_y_min;
-    if (new_y_max < m_y_max) new_y_max = m_y_max;
+    if (new_x_min > m_x_min)
+    {
+      new_x_min = m_x_min;
+    }
+    if (new_x_max < m_x_max)
+    {
+      new_x_max = m_x_max;
+    }
+    if (new_y_min > m_y_min)
+    {
+      new_y_min = m_y_min;
+    }
+    if (new_y_max < m_y_max)
+    {
+      new_y_max = m_y_max;
+    }
 
     // Additional margin:
     if (additionalMarginMeters > 0)
     {
-      if (new_x_min < m_x_min) new_x_min = floor(new_x_min - additionalMarginMeters);
-      if (new_x_max > m_x_max) new_x_max = ceil(new_x_max + additionalMarginMeters);
-      if (new_y_min < m_y_min) new_y_min = floor(new_y_min - additionalMarginMeters);
-      if (new_y_max > m_y_max) new_y_max = ceil(new_y_max + additionalMarginMeters);
+      if (new_x_min < m_x_min)
+      {
+        new_x_min = floor(new_x_min - additionalMarginMeters);
+      }
+      if (new_x_max > m_x_max)
+      {
+        new_x_max = ceil(new_x_max + additionalMarginMeters);
+      }
+      if (new_y_min < m_y_min)
+      {
+        new_y_min = floor(new_y_min - additionalMarginMeters);
+      }
+      if (new_y_max > m_y_max)
+      {
+        new_y_max = ceil(new_y_max + additionalMarginMeters);
+      }
     }
 
     // Adjust sizes to adapt them to full sized cells according to the
     // resolution:
     if (fabs(new_x_min / m_resolution - round(new_x_min / m_resolution)) > 0.05)
+    {
       new_x_min = m_resolution * round(new_x_min / m_resolution);
+    }
     if (fabs(new_y_min / m_resolution - round(new_y_min / m_resolution)) > 0.05)
+    {
       new_y_min = m_resolution * round(new_y_min / m_resolution);
+    }
     if (fabs(new_x_max / m_resolution - round(new_x_max / m_resolution)) > 0.05)
+    {
       new_x_max = m_resolution * round(new_x_max / m_resolution);
+    }
     if (fabs(new_y_max / m_resolution - round(new_y_max / m_resolution)) > 0.05)
+    {
       new_y_max = m_resolution * round(new_y_max / m_resolution);
+    }
 
     // Change the map size: Extensions at each side:
     const auto extra_x_left = static_cast<std::size_t>(round((m_x_min - new_x_min) / m_resolution));
@@ -205,17 +240,29 @@ class CDynamicGrid
   {
     const int cx = x2idx(x);
     const int cy = y2idx(y);
-    if (cx < 0 || cx >= static_cast<int>(m_size_x)) return nullptr;
-    if (cy < 0 || cy >= static_cast<int>(m_size_y)) return nullptr;
+    if (cx < 0 || cx >= static_cast<int>(m_size_x))
+    {
+      return nullptr;
+    }
+    if (cy < 0 || cy >= static_cast<int>(m_size_y))
+    {
+      return nullptr;
+    }
     return &m_map[static_cast<size_t>(cx) + static_cast<size_t>(cy) * m_size_x];
   }
   /** \overload */
   inline const T* cellByPos(double x, double y) const
   {
     const int cx = x2idx(x);
     const int cy = y2idx(y);
-    if (cx < 0 || cx >= static_cast<int>(m_size_x)) return nullptr;
-    if (cy < 0 || cy >= static_cast<int>(m_size_y)) return nullptr;
+    if (cx < 0 || cx >= static_cast<int>(m_size_x))
+    {
+      return nullptr;
+    }
+    if (cy < 0 || cy >= static_cast<int>(m_size_y))
+    {
+      return nullptr;
+    }
     return &m_map[static_cast<size_t>(cx) + static_cast<size_t>(cy) * m_size_x];
   }
 
@@ -225,9 +272,10 @@ class CDynamicGrid
   inline T* cellByIndex(unsigned int cx, unsigned int cy)
   {
     if (cx >= m_size_x || cy >= m_size_y)
+    {
       return nullptr;
-    else
-      return &m_map[cx + cy * m_size_x];
+    }
+    return &m_map[cx + cy * m_size_x];
   }
 
   /** Returns a pointer to the contents of a cell given by its cell indexes,
@@ -236,9 +284,10 @@ class CDynamicGrid
   inline const T* cellByIndex(unsigned int cx, unsigned int cy) const
   {
     if (cx >= m_size_x || cy >= m_size_y)
+    {
       return nullptr;
-    else
-      return &m_map[cx + cy * m_size_x];
+    }
+    return &m_map[cx + cy * m_size_x];
   }
 
   /** Returns the horizontal size of grid map in cells count */
@@ -287,10 +336,18 @@ class CDynamicGrid
   void getAsMatrix(MAT& m) const
   {
     m.setSize(m_size_y, m_size_x);
-    if (m_map.empty()) return;
+    if (m_map.empty())
+    {
+      return;
+    }
     const T* c = &m_map[0];
     for (size_t cy = 0; cy < m_size_y; cy++)
-      for (size_t cx = 0; cx < m_size_x; cx++) m(cy, cx) = *c++;
+    {
+      for (size_t cx = 0; cx < m_size_x; cx++)
+      {
+        m(cy, cx) = *c++;
+      }
+    }
   }
 
   /** The user must implement this in order to provide "saveToTextFile" a way

modules/mrpt_containers/include/mrpt/containers/bimap.h

@@ -94,7 +94,10 @@ class bimap
 
     if (!keyExists && valueExists) THROW_EXCEPTION("Duplicated `value` with different `key`");
 
-    if (keyExists && valueExists && itKey->second == v) return;  // Ok
+    if (keyExists && valueExists && itKey->second == v)
+    {
+      return;  // Ok
+    }
 
     // New:
     m_k2v[k] = v;
@@ -109,7 +112,10 @@ class bimap
   bool direct(const KEY& k, VALUE& out_v) const
   {
     const_iterator i = m_k2v.find(k);
-    if (i == m_k2v.end()) return false;
+    if (i == m_k2v.end())
+    {
+      return false;
+    }
     out_v = i->second;
     return true;
   }
@@ -142,7 +148,10 @@ class bimap
   bool inverse(const VALUE& v, KEY& out_k) const
   {
     const_iterator_inverse i = m_v2k.find(v);
-    if (i == m_v2k.end()) return false;
+    if (i == m_v2k.end())
+    {
+      return false;
+    }
     out_k = i->second;
     return true;
   }

modules/mrpt_containers/include/mrpt/containers/circular_buffer.h

@@ -30,7 +30,10 @@ class circular_buffer
  public:
   circular_buffer(size_t size) : m_data(size), m_size(size), m_next_read(0), m_next_write(0)
   {
-    if (m_size <= 2) throw std::invalid_argument("size must be >2");
+    if (m_size <= 2)
+    {
+      throw std::invalid_argument("size must be >2");
+    }
   }
 
   /** Insert a copy of the given element in the buffer.
@@ -39,8 +42,14 @@ class circular_buffer
   void push(T d)
   {
     auto new_idx = m_next_write + 1;
-    if (new_idx == m_size) new_idx = 0;
-    if (new_idx == m_next_read) throw std::out_of_range("push: circular_buffer is full");
+    if (new_idx == m_size)
+    {
+      new_idx = 0;
+    }
+    if (new_idx == m_next_read)
+    {
+      throw std::out_of_range("push: circular_buffer is full");
+    }
     m_data[m_next_write] = d;
     m_next_write = new_idx;
   }
@@ -51,28 +60,43 @@ class circular_buffer
   void push_ref(const T& d)
   {
     m_data[m_next_write++] = d;
-    if (m_next_write == m_size) m_next_write = 0;
+    if (m_next_write == m_size)
+    {
+      m_next_write = 0;
+    }
 
-    if (m_next_write == m_next_read) throw std::out_of_range("push: circular_buffer is full");
+    if (m_next_write == m_next_read)
+    {
+      throw std::out_of_range("push: circular_buffer is full");
+    }
   }
 
   /** Insert an array of elements in the buffer.
    * \exception std::out_of_range If the buffer run out of space.
    */
   void push_many(T* array_elements, size_t count)
   {
-    while (count--) push(*array_elements++);
+    while (count--)
+    {
+      push(*array_elements++);
+    }
   }
 
   /** Retrieve an element from the buffer.
    * \exception std::out_of_range If the buffer is empty.
    */
   T pop()
   {
-    if (m_next_read == m_next_write) throw std::out_of_range("pop: circular_buffer is empty");
+    if (m_next_read == m_next_write)
+    {
+      throw std::out_of_range("pop: circular_buffer is empty");
+    }
 
     const size_t i = m_next_read++;
-    if (m_next_read == m_size) m_next_read = 0;
+    if (m_next_read == m_size)
+    {
+      m_next_read = 0;
+    }
     return m_data[i];
   }
 
@@ -81,26 +105,38 @@ class circular_buffer
    */
   void pop(T& out_val)
   {
-    if (m_next_read == m_next_write) throw std::out_of_range("pop: circular_buffer is empty");
+    if (m_next_read == m_next_write)
+    {
+      throw std::out_of_range("pop: circular_buffer is empty");
+    }
 
     out_val = m_data[m_next_read++];
-    if (m_next_read == m_size) m_next_read = 0;
+    if (m_next_read == m_size)
+    {
+      m_next_read = 0;
+    }
   }
 
   /** Pop a number of elements into a user-provided array.
    * \exception std::out_of_range If the buffer has less elements than
    * requested. */
   void pop_many(T* out_array, size_t count)
   {
-    while (count--) pop(*out_array++);
+    while (count--)
+    {
+      pop(*out_array++);
+    }
   }
 
   /** Peek (see without modifying) what is to be read from the buffer if pop()
    * was to be called.
    * \exception std::out_of_range If the buffer is empty. */
   T peek() const
   {
-    if (m_next_read == m_next_write) throw std::out_of_range("peek: circular_buffer is empty");
+    if (m_next_read == m_next_write)
+    {
+      throw std::out_of_range("peek: circular_buffer is empty");
+    }
     return m_data[m_next_read];
   }
   /** Like peek(), but seeking ahead in the buffer (index=0 means the
@@ -109,7 +145,10 @@ class circular_buffer
    * available elements. */
   T peek(size_t index) const
   {
-    if (index >= this->size()) throw std::out_of_range("peek: seek out of range");
+    if (index >= this->size())
+    {
+      throw std::out_of_range("peek: seek out of range");
+    }
     return m_data[(m_next_read + index) % m_size];
   }
 
@@ -122,9 +161,15 @@ class circular_buffer
     size_t peek_read = m_next_read;
     while (count--)
     {
-      if (peek_read == m_next_write) throw std::out_of_range("peek: circular_buffer is empty");
+      if (peek_read == m_next_write)
+      {
+        throw std::out_of_range("peek: circular_buffer is empty");
+      }
       T val = m_data[peek_read++];
-      if (peek_read == m_size) peek_read = 0;
+      if (peek_read == m_size)
+      {
+        peek_read = 0;
+      }
       *out_array++ = val;
     }
   }
@@ -135,9 +180,10 @@ class circular_buffer
   size_t size() const
   {
     if (m_next_write >= m_next_read)
+    {
       return m_next_write - m_next_read;
-    else
-      return m_next_write + (m_size - m_next_read);
+    }
+    return m_next_write + (m_size - m_next_read);
   }
 
   /** Return the maximum capacity of the buffer.