Added a number of typename qualifier to deal with old versions of gcc.

clang-format

Author: eric-hughes-tiledb

tiledb/api/c_api_test_support/storage_manager_stub/storage_manager_override.h

@@ -48,9 +48,7 @@ class StorageManagerStub {
 
  public:
   static constexpr bool is_overriding_class = true;
-  StorageManagerStub(
-      ContextResources&,
-      const Config& config)
+  StorageManagerStub(ContextResources&, const Config& config)
       : config_(config) {
   }
 

tiledb/common/registry/registry.h

@@ -167,7 +167,7 @@ class Registry {
   /**
    * The iterator type is only visible to friends.
    */
-  using registry_iterator_type = registry_list_type::iterator;
+  using registry_iterator_type = typename registry_list_type::iterator;
 
   /**
    * List of entries with this registry
@@ -200,7 +200,7 @@ class Registry {
   /**
    * The return type of `size()` is forwarded from its underlying container.
    */
-  using size_type = registry_list_type::size_type;
+  using size_type = typename registry_list_type::size_type;
 
   /**
    * The handle type. A registered class should have a member variable of this
@@ -218,7 +218,7 @@ class Registry {
   const registry_handle_type register_item(value_type& item) {
     lock_guard_type lg(m_);
     registry_list_.emplace_back(item, *this);
-    cv_.notify_all();   // `emplace_back` adds one to the registry size
+    cv_.notify_all();  // `emplace_back` adds one to the registry size
     /*
      * `emplace_back` returns a reference to the list member, not its iterator.
      * We have to construct an iterator instead.
@@ -261,27 +261,23 @@ class Registry {
    * @param f A callable object of type F
    */
   template <class F>
-  void for_each(F f) const
-  {
+  void for_each(F f) const {
     lock_guard_type lg(m_);
     /*
      * We iterate over entries, but apply the function to valid items. Thus we
      * need to provide `for_each` with an adapter.
      */
-    auto g{
-        [&f](const RegistryEntry<T>& entry) -> void {
-          /*
-           * We can only iterate over items that have registered `shared_ptr`.
-           * Otherwise we might iterate over a dangling reference.
-           */
-          auto item_ptr{entry.item_ptr_.lock()};
-          if (item_ptr) {
-            f(*item_ptr);
-          }
-        }
-    };
-    std::for_each(
-        registry_list_.begin(), registry_list_.end(), g);
+    auto g{[&f](const RegistryEntry<T>& entry) -> void {
+      /*
+       * We can only iterate over items that have registered `shared_ptr`.
+       * Otherwise we might iterate over a dangling reference.
+       */
+      auto item_ptr{entry.item_ptr_.lock()};
+      if (item_ptr) {
+        f(*item_ptr);
+      }
+    }};
+    std::for_each(registry_list_.begin(), registry_list_.end(), g);
   }
 
  private:
@@ -301,7 +297,7 @@ class Registry {
   void deregister(registry_iterator_type& iter) {
     lock_guard_type lg(m_);
     registry_list_.erase(iter);
-    cv_.notify_all();   // `erase` subtracts one from the registry size
+    cv_.notify_all();  // `erase` subtracts one from the registry size
   }
 };
 
@@ -340,7 +336,7 @@ class RegistryHandle {
    * immediate erasure of the entry; there's no separate index or other
    * secondary structure required.
    */
-  using referential_type = Registry<T>::registry_iterator_type;
+  using referential_type = typename Registry<T>::registry_iterator_type;
 
   /**
    * The iterator that comprises the underlying data of this handle.
@@ -478,6 +474,6 @@ class RegistryHandle {
   }
 };
 
-}  // namespace tiledb::sm
+}  // namespace tiledb::common
 
 #endif  // TILEDB_REGISTRY_H

tiledb/common/registry/test/unit_registry.cc

@@ -57,9 +57,7 @@ struct Item {
 void check_size(const item_registry_type& r, item_registry_type::size_type n) {
   CHECK(r.size() == n);
   item_registry_type::size_type m{0};
-  auto f{[&m](const item_registry_type::value_type&) -> void {
-    ++m;
-  }};
+  auto f{[&m](const item_registry_type::value_type&) -> void { ++m; }};
   r.for_each(f);
   CHECK(r.size() == m);
 }
@@ -98,19 +96,19 @@ TEST_CASE("Registry - construct and add, two nested") {
  */
 TEST_CASE("Registry - construct and add, two interleaved") {
   item_registry_type r;
-  check_size(r,0);
+  check_size(r, 0);
   {
     auto i1{std::make_shared<Item>(r)};
     i1->register_shared_ptr(i1);
-    check_size(r,1);
+    check_size(r, 1);
     {
       auto i2{std::make_shared<Item>(r)};
       i2->register_shared_ptr(i2);
-      check_size(r,2);
+      check_size(r, 2);
       i1.reset();
-      check_size(r,1);
+      check_size(r, 1);
     }
-    check_size(r,0);
+    check_size(r, 0);
   }
-  check_size(r,0);
+  check_size(r, 0);
 }

tiledb/sm/consolidator/consolidator.cc

@@ -330,8 +330,7 @@ void Consolidator::array_vacuum(
   }
 
   auto mode = Consolidator::mode_from_config(config, true);
-  auto consolidator =
-      Consolidator::create(parent, mode, config);
+  auto consolidator = Consolidator::create(parent, mode, config);
   consolidator->vacuum(array_name);
 }
 

tiledb/sm/consolidator/fragment_consolidator.cc

@@ -685,12 +685,8 @@ Status FragmentConsolidator::create_queries(
   // is not a user input prone to errors).
 
   // Create read query
-  query_r = tdb_unique_ptr<Query>(tdb_new(
-      Query,
-      *this,
-      array_for_reads,
-      nullopt,
-      read_memory_budget));
+  query_r = tdb_unique_ptr<Query>(
+      tdb_new(Query, *this, array_for_reads, nullopt, read_memory_budget));
   throw_if_not_ok(query_r->set_layout(Layout::GLOBAL_ORDER));
 
   // Dense consolidation will do a tile aligned read.
@@ -716,11 +712,7 @@ Status FragmentConsolidator::create_queries(
 
   // Create write query
   query_w = tdb_unique_ptr<Query>(tdb_new(
-      Query,
-      *this,
-      array_for_writes,
-      fragment_name,
-      write_memory_budget));
+      Query, *this, array_for_writes, fragment_name, write_memory_budget));
   throw_if_not_ok(query_w->set_layout(Layout::GLOBAL_ORDER));
   throw_if_not_ok(query_w->disable_checks_consolidation());
   query_w->set_fragment_size(config_.max_fragment_size_);

tiledb/sm/group/group_details_v2.cc

@@ -30,8 +30,8 @@
  * This file implements TileDB Group Details V2
  */
 
-#include "group.h"
 #include "tiledb/sm/group/group_details_v2.h"
+#include "group.h"
 #include "tiledb/common/common.h"
 #include "tiledb/common/logger.h"
 

tiledb/sm/query/dimension_label/array_dimension_label_queries.cc

@@ -248,11 +248,7 @@ void ArrayDimensionLabelQueries::add_read_queries(
 
       // Create the range query.
       range_queries_.emplace_back(tdb_new(
-          DimensionLabelQuery,
-          *this,
-          dim_label,
-          dim_label_ref,
-          label_ranges));
+          DimensionLabelQuery, *this, dim_label, dim_label_ref, label_ranges));
       label_range_queries_by_dim_idx_[dim_idx] = range_queries_.back().get();
     } catch (const StatusException& err) {
       throw DimensionLabelQueryException(

tiledb/sm/query/query.h

@@ -55,8 +55,8 @@
 #include "tiledb/sm/query/update_value.h"
 #include "tiledb/sm/query/validity_vector.h"
 #include "tiledb/sm/rest/rest_client.h"
-#include "tiledb/sm/storage_manager/job.h"
 #include "tiledb/sm/storage_manager/cancellation_source.h"
+#include "tiledb/sm/storage_manager/job.h"
 #include "tiledb/sm/subarray/subarray.h"
 
 using namespace tiledb::common;

tiledb/sm/storage_manager/context.cc

@@ -156,19 +156,17 @@ Status get_config_thread_count(
 }
 
 /**
-   * Obtain the number of threads in a compute thread pool from a configuration
-   *
-   * Returns the maximum of the configured value and the thread count returned
-   * from get_config_thread_count().
-   *
-   * @param config A configuration that specifies the compute thread
-   * @return Compute thread count
+ * Obtain the number of threads in a compute thread pool from a configuration
+ *
+ * Returns the maximum of the configured value and the thread count returned
+ * from get_config_thread_count().
+ *
+ * @param config A configuration that specifies the compute thread
+ * @return Compute thread count
  */
-size_t get_compute_thread_count(
-    Logger& logger, const Config& config) {
+size_t get_compute_thread_count(Logger& logger, const Config& config) {
   uint64_t config_thread_count{0};
-  if (!get_config_thread_count(logger, config, config_thread_count)
-           .ok()) {
+  if (!get_config_thread_count(logger, config, config_thread_count).ok()) {
     throw std::logic_error("Cannot get compute thread count");
   }
 
@@ -190,8 +188,7 @@ size_t get_compute_thread_count(
 
 size_t get_io_thread_count(Logger& logger, const Config& config) {
   uint64_t config_thread_count{0};
-  if (!get_config_thread_count(logger, config, config_thread_count)
-           .ok()) {
+  if (!get_config_thread_count(logger, config, config_thread_count).ok()) {
     throw std::logic_error("Cannot get config thread count");
   }
 
@@ -236,8 +233,7 @@ Context::Context(const Config& config)
     : ContextBase(config)
     , JobRoot{storage_manager_}
     , context_handle_(ContextRegistry::get().register_context(*this))
-    , last_error_(nullopt)
-{
+    , last_error_(nullopt) {
   /*
    * Logger class is not yet C.41-compliant
    */

tiledb/sm/storage_manager/context_registry.cc

@@ -33,6 +33,4 @@
 
 #include "context_registry.h"
 
-namespace tiledb::sm {
-
-}  // namespace tiledb::sm
+namespace tiledb::sm {}  // namespace tiledb::sm