null_count_policy.hpp

Go to the documentation of this file.

// 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.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <utility>
 
#include "sparrow/config/config.hpp"
 
namespace sparrow
{
    [[nodiscard]] SPARROW_API std::size_t count_non_null(
        const std::uint8_t* data,
        std::size_t bit_size,
        std::size_t byte_size,
        std::size_t offset = 0
    ) noexcept;

    template <typename SizeType = std::size_t>
    class tracking_null_count
    {
    public:
 
        static constexpr bool track_null_count = true;
        using size_type = SizeType;
 
        constexpr tracking_null_count() noexcept = default;
 
        constexpr explicit tracking_null_count(size_type count) noexcept
            : m_null_count(count)
        {
        }

        template <std::integral BlockType>
        void initialize_null_count(
            const BlockType* data,
            size_type bit_size,
            size_type block_count,
            size_type offset = 0
        ) noexcept
        {
            recompute_null_count(data, bit_size, block_count, offset);
        }
 
        [[nodiscard]] constexpr size_type null_count() const noexcept
        {
            return m_null_count;
        }
 
        constexpr void set_null_count(size_type count) noexcept
        {
            m_null_count = count;
        }

        template <std::integral BlockType>
        void
        recompute_null_count(const BlockType* data, size_type bit_size, size_type block_count, size_type offset = 0) noexcept
        {
            const auto* byte_data = reinterpret_cast<const std::uint8_t*>(data);
            const std::size_t byte_size = block_count * sizeof(BlockType);
            m_null_count = static_cast<size_type>(bit_size)
                           - static_cast<size_type>(count_non_null(
                               byte_data,
                               static_cast<std::size_t>(bit_size),
                               byte_size,
                               static_cast<std::size_t>(offset)
                           ));
        }
 
        constexpr void update_null_count(bool old_value, bool new_value) noexcept
        {
            if (new_value && !old_value)
            {
                --m_null_count;
            }
            else if (!new_value && old_value)
            {
                ++m_null_count;
            }
        }
 
        constexpr void swap_null_count(tracking_null_count& other) noexcept
        {
            std::swap(m_null_count, other.m_null_count);
        }
 
        constexpr void clear_null_count() noexcept
        {
            m_null_count = 0;
        }
 
    private:
 
        size_type m_null_count = 0;
    };

    template <typename SizeType = std::size_t>
    class non_tracking_null_count
    {
    public:
 
        static constexpr bool track_null_count = false;
        using size_type = SizeType;
 
        constexpr non_tracking_null_count() noexcept = default;
 
        // Accepts and ignores a count for interface compatibility
        constexpr explicit non_tracking_null_count(size_type /*count*/) noexcept
        {
        }
 
        // null_count() is intentionally not provided
 
        // No-op: non-tracking policy doesn't need to count bits
        template <std::integral BlockType>
        constexpr void initialize_null_count(
            const BlockType* /*data*/,
            size_type /*bit_size*/,
            size_type /*block_count*/,
            size_type /*offset*/ = 0
        ) noexcept
        {
        }
 
        constexpr void set_null_count(size_type /*count*/) noexcept
        {
            // No-op
        }
 
        // No-op: non-tracking policy doesn't need to recompute
        template <std::integral BlockType>
        constexpr void recompute_null_count(
            const BlockType* /*data*/,
            size_type /*bit_size*/,
            size_type /*block_count*/,
            size_type /*offset*/ = 0
        ) noexcept
        {
        }
 
        constexpr void update_null_count(bool /*old_value*/, bool /*new_value*/) noexcept
        {
            // No-op
        }
 
        constexpr void swap_null_count(non_tracking_null_count& /*other*/) noexcept
        {
            // No-op
        }
 
        constexpr void clear_null_count() noexcept
        {
            // No-op
        }
    };

    template <typename P>
    concept null_count_policy = requires(P p, P other, bool b, typename P::size_type s, const std::uint8_t* data) {
        { P::track_null_count } -> std::convertible_to<bool>;
        { p.update_null_count(b, b) } -> std::same_as<void>;
        { p.swap_null_count(other) } -> std::same_as<void>;
        { p.clear_null_count() } -> std::same_as<void>;
        { p.set_null_count(s) } -> std::same_as<void>;
        { p.initialize_null_count(data, s, s) } -> std::same_as<void>;
        { p.recompute_null_count(data, s, s) } -> std::same_as<void>;
    };
 
}  // namespace sparrow