[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

include/sparrow/layout/map_layout/map_array.hpp

@@ -101,7 +101,7 @@ namespace sparrow
 
         [[nodiscard]] inner_reference value(size_type i);
         [[nodiscard]] inner_const_reference value(size_type i) const;
-        
+
         [[nodiscard]] offset_type* make_list_offsets() const;
         [[nodiscard]] cloning_ptr<array_wrapper> make_keys_array() const;
         [[nodiscard]] cloning_ptr<array_wrapper> make_items_array() const;
@@ -144,7 +144,7 @@ namespace sparrow
             );
         }
 
-       template <
+        template <
             validity_bitmap_input VB = validity_bitmap,
             input_metadata_container METADATA_RANGE = std::vector<metadata_pair>>
         [[nodiscard]] static arrow_proxy create_proxy(
@@ -225,16 +225,17 @@ namespace sparrow
 
         ArrowSchema schema = make_arrow_schema(
             std::string("+m"),
-            name,                                                          // name
-            metadata,                                                      // metadata
-            flags,                                                         // flags,
-            new ArrowSchema*[2]{                                           // Children
+            name,      // name
+            metadata,  // metadata
+            flags,     // flags,
+            new ArrowSchema*[2]{
+                // Children
                 new ArrowSchema(std::move(flat_keys_schema)),
                 new ArrowSchema(std::move(flat_items_schema))
             },
-            children_ownership,                                            // children ownership
-            nullptr,                                                       // dictionary
-            true                                                           // dictionary ownership
+            children_ownership,  // children ownership
+            nullptr,             // dictionary
+            true                 // dictionary ownership
 
         );
         std::vector<buffer<std::uint8_t>> arr_buffs = {
@@ -247,13 +248,10 @@ namespace sparrow
             static_cast<int64_t>(null_count),
             0,  // offset
             std::move(arr_buffs),
-            new ArrowArray*[2]{
-                new ArrowArray(std::move(flat_keys_arr)),
-                new ArrowArray(std::move(flat_items_arr))
-            },
-            children_ownership,                                       // children ownership
-            nullptr,                                                  // dictionary
-            true                                                      // dictionary ownership
+            new ArrowArray*[2]{new ArrowArray(std::move(flat_keys_arr)), new ArrowArray(std::move(flat_items_arr))},
+            children_ownership,  // children ownership
+            nullptr,             // dictionary
+            true                 // dictionary ownership
         );
         return arrow_proxy{std::move(arr), std::move(schema)};
     }
@@ -287,17 +285,18 @@ namespace sparrow
             const repeat_view<bool> children_ownership{true, 2};
 
             ArrowSchema schema = make_arrow_schema(
-                std::string("+m"),                                             // format
-                name,                                                          // name
-                metadata,                                                      // metadata
-                std::nullopt,                                                  // flags,
-                new ArrowSchema*[2]{                                           // Children
+                std::string("+m"),  // format
+                name,               // name
+                metadata,           // metadata
+                std::nullopt,       // flags,
+                new ArrowSchema*[2]{
+                    // Children
                     new ArrowSchema(std::move(flat_keys_schema)),
                     new ArrowSchema(std::move(flat_items_schema))
                 },
-                children_ownership,                                            // children ownership
-                nullptr,                                                       // dictionary
-                true                                                           // dictionary ownership
+                children_ownership,  // children ownership
+                nullptr,             // dictionary
+                true                 // dictionary ownership
 
             );
             std::vector<buffer<std::uint8_t>> arr_buffs = {
@@ -314,9 +313,9 @@ namespace sparrow
                     new ArrowArray(std::move(flat_keys_arr)),
                     new ArrowArray(std::move(flat_items_arr))
                 },
-                children_ownership,                                       // children ownership
-                nullptr,                                                  // dictionary
-                true                                                      // dictionary ownership
+                children_ownership,  // children ownership
+                nullptr,             // dictionary
+                true                 // dictionary ownership
             );
             return arrow_proxy{std::move(arr), std::move(schema)};
         }

include/sparrow/layout/map_layout/map_value.hpp

@@ -40,8 +40,13 @@ namespace sparrow
         using const_iterator = functor_index_iterator<functor_type>;
 
         map_value() = default;
-        map_value(const array_wrapper* flat_keys, const array_wrapper* flat_items,
-                size_type index_begin, size_type index_end, bool keys_sorted);
+        map_value(
+            const array_wrapper* flat_keys,
+            const array_wrapper* flat_items,
+            size_type index_begin,
+            size_type index_end,
+            bool keys_sorted
+        );
 
         bool empty() const noexcept;
         size_type size() const noexcept;

src/layout/map_layout/map_array.cpp

@@ -67,22 +67,22 @@ namespace sparrow
         return p_items_array.get();
     }
 
-    auto map_array::value_begin() -> value_iterator 
+    auto map_array::value_begin() -> value_iterator
     {
         return value_iterator(value_iterator::functor_type(this), 0);
     }
 
-    auto map_array::value_end() -> value_iterator 
+    auto map_array::value_end() -> value_iterator
     {
         return value_iterator(value_iterator::functor_type(this), this->size());
     }
 
-    auto map_array::value_cbegin() const -> const_value_iterator 
+    auto map_array::value_cbegin() const -> const_value_iterator
     {
         return const_value_iterator(const_value_iterator::functor_type(this), 0);
     }
 
-    auto map_array::value_cend() const -> const_value_iterator 
+    auto map_array::value_cend() const -> const_value_iterator
     {
         return const_value_iterator(const_value_iterator::functor_type(this), this->size());
     }
@@ -95,10 +95,9 @@ namespace sparrow
     auto map_array::value(size_type i) const -> inner_const_reference
     {
         using st = size_type;
-        return map_value(raw_keys_array(), raw_items_array(), p_list_offsets[i], p_list_offsets[i+1],
-                m_keys_sorted);
+        return map_value(raw_keys_array(), raw_items_array(), p_list_offsets[i], p_list_offsets[i + 1], m_keys_sorted);
     }
-    
+
     auto map_array::make_list_offsets() const -> offset_type*
     {
         return reinterpret_cast<offset_type*>(

src/layout/map_layout/map_value.cpp

@@ -19,8 +19,13 @@
 
 namespace sparrow
 {
-    map_value::map_value(const array_wrapper* flat_keys, const array_wrapper* flat_items,
-        size_type index_begin, size_type index_end, bool keys_sorted)
+    map_value::map_value(
+        const array_wrapper* flat_keys,
+        const array_wrapper* flat_items,
+        size_type index_begin,
+        size_type index_end,
+        bool keys_sorted
+    )
         : p_flat_keys(flat_keys)
         , p_flat_items(flat_items)
         , m_index_begin(index_begin)
@@ -39,7 +44,7 @@ namespace sparrow
         return m_index_end - m_index_begin;
     }
 
-    auto map_value::operator[](const key_type& key) const -> const_mapped_reference 
+    auto map_value::operator[](const key_type& key) const -> const_mapped_reference
     {
         size_type index = find_index(key);
         if (index == m_index_end)
@@ -76,7 +81,7 @@ namespace sparrow
 
     auto map_value::find_index(const key_type& key) const noexcept -> size_type
     {
-#if SPARROW_GCC_11_2_WORKAROUND 
+#if SPARROW_GCC_11_2_WORKAROUND
         using T0 = sparrow::nullable<sparrow::null_type, bool>;
         using T1 = sparrow::nullable<bool, bool>;
         using T2 = sparrow::nullable<unsigned char, bool>;
@@ -90,23 +95,35 @@ namespace sparrow
         using T11 = sparrow::nullable<numeric::float16_t, bool>;
         using T12 = sparrow::nullable<float, bool>;
         using T13 = sparrow::nullable<double, bool>;
-        using T14 = sparrow::nullable<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool>;
-        using T15 = sparrow::nullable<std::vector<std::byte, std::allocator<std::byte> >, bool>;
-        using T16 = sparrow::nullable<std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<int, std::ratio<86400, 1> > >, bool>;
-        using T17 = sparrow::nullable<std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long int, std::ratio<1, 1000> > >, bool>;
-        using T18 = sparrow::nullable<date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1> >, const date::time_zone*>, bool>;
-        using T19 = sparrow::nullable<date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000> >, const date::time_zone*>, bool>;
-        using T20 = sparrow::nullable<date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000000> >, const date::time_zone*>, bool>;
-        using T21 = sparrow::nullable<date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000000000> >, const date::time_zone*>, bool>;
+        using T14 = sparrow::nullable<std::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool>;
+        using T15 = sparrow::nullable<std::vector<std::byte, std::allocator<std::byte>>, bool>;
+        using T16 = sparrow::nullable<
+            std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<int, std::ratio<86400, 1>>>,
+            bool>;
+        using T17 = sparrow::nullable<
+            std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long int, std::ratio<1, 1000>>>,
+            bool>;
+        using T18 = sparrow::nullable<
+            date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1>>, const date::time_zone*>,
+            bool>;
+        using T19 = sparrow::nullable<
+            date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000>>, const date::time_zone*>,
+            bool>;
+        using T20 = sparrow::nullable<
+            date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000000>>, const date::time_zone*>,
+            bool>;
+        using T21 = sparrow::nullable<
+            date::zoned_time<std::chrono::duration<long int, std::ratio<1, 1000000000>>, const date::time_zone*>,
+            bool>;
         using T22 = sparrow::nullable<sparrow::zoned_time_without_timezone_seconds, bool>;
         using T23 = sparrow::nullable<sparrow::zoned_time_without_timezone_milliseconds, bool>;
         using T24 = sparrow::nullable<sparrow::zoned_time_without_timezone_microseconds, bool>;
         using T25 = sparrow::nullable<sparrow::zoned_time_without_timezone_nanoseconds, bool>;
-        using T26 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1> >, bool>;
-        using T27 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000> >, bool>;
-        using T28 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000000> >, bool>;
-        using T29 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000000000> >, bool>;
-        using T30 = sparrow::nullable<std::chrono::duration<int, std::ratio<2629746, 1> >, bool>;
+        using T26 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1>>, bool>;
+        using T27 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000>>, bool>;
+        using T28 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000000>>, bool>;
+        using T29 = sparrow::nullable<std::chrono::duration<long int, std::ratio<1, 1000000000>>, bool>;
+        using T30 = sparrow::nullable<std::chrono::duration<int, std::ratio<2629746, 1>>, bool>;
         using T31 = sparrow::nullable<sparrow::days_time_interval, bool>;
         using T32 = sparrow::nullable<sparrow::month_day_nanoseconds_interval, bool>;
         using T33 = sparrow::nullable<sparrow::chrono::time_seconds, bool>;
@@ -166,24 +183,32 @@ namespace sparrow
         T43 t43;
         return size_type(0);
 #else
-        return std::visit([this](const auto& k) {
-            return visit([&k, this](const auto& ar) {
-                for (size_type i = m_index_begin; i != m_index_end; ++i)
-                {
-                    const auto& val = ar[i];
-                    using T = std::decay_t<decltype(k)>;
-                    using U = std::decay_t<decltype(val)>;
-                    if constexpr (std::same_as<T, U>)
+        return std::visit(
+            [this](const auto& k)
+            {
+                return visit(
+                    [&k, this](const auto& ar)
                     {
-                        if (val == k)
+                        for (size_type i = m_index_begin; i != m_index_end; ++i)
                         {
-                            return i;
+                            const auto& val = ar[i];
+                            using T = std::decay_t<decltype(k)>;
+                            using U = std::decay_t<decltype(val)>;
+                            if constexpr (std::same_as<T, U>)
+                            {
+                                if (val == k)
+                                {
+                                    return i;
+                                }
+                            }
                         }
-                    }
-                }
-                return m_index_end;
-            }, *p_flat_keys);
-        }, key);
+                        return m_index_end;
+                    },
+                    *p_flat_keys
+                );
+            },
+            key
+        );
 #endif
     }
 

test/test_list_value.cpp

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 #include "sparrow/layout/list_layout/list_value.hpp"
-#include "sparrow/layout/primitive_layout/primitive_array.hpp"
 #include "sparrow/layout/map_layout/map_value.hpp"
+#include "sparrow/layout/primitive_layout/primitive_array.hpp"
 #include "sparrow/layout/struct_layout/struct_value.hpp"
 
 #include "../test/external_array_data_creation.hpp"