Add warnings options

.clang-format

@@ -46,6 +46,7 @@ IncludeCategories:
 - Regex: '".+"'
  Priority: 5
 IndentCaseLabels: true
+IndentPPDirectives: AfterHash
 IndentWidth: '4'
 IndentWrappedFunctionNames: false
 InsertBraces: true

include/sparrow/allocator.hpp

@@ -231,7 +231,14 @@ namespace sparrow
  return visit_storage(
  [n, p](auto& allocator)
  {
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmismatched-new-delete"
+#endif
  return allocator.deallocate(p, n);
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
  }
  );
  }

include/sparrow/array_data.hpp

@@ -1,4 +1,4 @@
 // Copyright 2024 Man Group Operations Limited
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -18,12 +18,13 @@
 #include <optional>
 #include <vector>
 
-#include "sparrow/contracts.hpp"
 #include "sparrow/buffer.hpp"
+#include "sparrow/contracts.hpp"
 #include "sparrow/data_type.hpp"
 #include "sparrow/dynamic_bitset.hpp"
 #include "sparrow/memory.hpp"
 
+
 namespace sparrow
 {
  /**

include/sparrow/buffer.hpp

@@ -1,4 +1,4 @@
 // Copyright 2024 Man Group Operations Limited
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -20,11 +20,12 @@
 #include <iterator>
 #include <stdexcept>
 
-#include "sparrow/contracts.hpp"
 #include "sparrow/allocator.hpp"
+#include "sparrow/contracts.hpp"
 #include "sparrow/iterator.hpp"
 #include "sparrow/mp_utils.hpp"
 
+
 namespace sparrow
 {
 
@@ -312,7 +313,7 @@
  template <class T>
  buffer_base<T>::~buffer_base()
  {
- deallocate(m_data.p_begin, (m_data.p_storage_end - m_data.p_begin));
+ deallocate(m_data.p_begin, static_cast<size_type>(m_data.p_storage_end - m_data.p_begin));
  }
 
  template <class T>
@@ -414,7 +415,7 @@
  template <class T>
  template <class It, allocator A>
  constexpr buffer<T>::buffer(It first, It last, const A& a)
- : base_type(check_init_length(std::distance(first, last), a), a)
+ : base_type(check_init_length(static_cast<size_type>(std::distance(first, last)), a), a)
  {
  get_data().p_end = copy_initialize(first, last, get_data().p_begin, get_allocator());
  }
@@ -666,7 +667,10 @@
  std::make_move_iterator(get_data().p_end)
  );
  destroy(get_data().p_begin, get_data().p_end, get_allocator());
- this->deallocate(get_data().p_begin, get_data().p_storage_end - get_data().p_begin);
+ this->deallocate(
+ get_data().p_begin,
+ static_cast<size_type>(get_data().p_storage_end - get_data().p_begin)
+ );
  this->assign_storage(tmp, old_size, new_cap);
  }
  }
@@ -744,7 +748,7 @@
  constexpr void buffer<T>::assign_range_impl(It first, It last, std::forward_iterator_tag)
  {
  const size_type sz = size();
- const size_type len = std::distance(first, last);
+ const size_type len = static_cast<size_type>(std::distance(first, last));
  if (len > capacity())
  {
  check_init_length(len, get_allocator());
@@ -804,7 +808,7 @@
  template <class T>
  constexpr auto buffer<T>::max_size_impl(const allocator_type& a) noexcept -> size_type
  {
- const size_type diff_max = std::numeric_limits<difference_type>::max();
+ const size_type diff_max = static_cast<size_type>(std::numeric_limits<difference_type>::max());
  const size_type alloc_max = std::allocator_traits<allocator_type>::max_size(a);
  return (std::min)(diff_max, alloc_max);
  }

include/sparrow/buffer_view.hpp

@@ -15,6 +15,7 @@
 #pragma once
 
 #include "sparrow/buffer.hpp"
+#include "sparrow/contracts.hpp"
 
 namespace sparrow
 {
@@ -23,7 +24,7 @@ namespace sparrow
  *
  * Although this class looks very similar to std::span, it provides
  * methods that are missing in C++20 std::span (like cbegin / cend),
- * and additional std::vector-like APIs. 
+ * and additional std::vector-like APIs.
  */
  template <class T>
  class buffer_view
@@ -130,42 +131,42 @@ namespace sparrow
  template <class T>
  auto buffer_view<T>::operator[](size_type pos) -> reference
  {
- assert(pos < size());
+ SPARROW_ASSERT_TRUE(pos < size());
  return data()[pos];
  }
 
  template <class T>
  auto buffer_view<T>::operator[](size_type pos) const -> const_reference
  {
- assert(pos < size());
+ SPARROW_ASSERT_TRUE(pos < size());
  return data()[pos];
  }
 
  template <class T>
  auto buffer_view<T>::front() -> reference
  {
- assert(!empty());
+ SPARROW_ASSERT_TRUE(!empty());
  return data()[0];
  }
 
  template <class T>
  auto buffer_view<T>::front() const -> const_reference
  {
- assert(!empty());
+ SPARROW_ASSERT_TRUE(!empty());
  return data()[0];
  }
 
  template <class T>
  auto buffer_view<T>::back() -> reference
  {
- assert(!empty());
+ SPARROW_ASSERT_TRUE(!empty());
  return data()[m_size - 1];
  }
 
  template <class T>
  auto buffer_view<T>::back() const -> const_reference
  {
- assert(!empty());
+ SPARROW_ASSERT_TRUE(!empty());
  return data()[m_size - 1];
  }