metadata.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 <cstring>
#include <numeric>
#include <ranges>
#include <string_view>
#include <utility>
 
#include "sparrow/config/config.hpp"
#include "sparrow/utils/contracts.hpp"
#include "sparrow/utils/ranges.hpp"
 
#if defined(__cpp_lib_format)
#    include <format>
#    include <ostream>
#endif
 
namespace sparrow
{
    using metadata_key = std::string;
    using metadata_key_const_reference = std::string_view;

    using metadata_value = std::string;
    using metadata_value_const_reference = std::string_view;

    using metadata_pair = std::pair<metadata_key, metadata_value>;
    using metadata_pair_const_reference = std::pair<metadata_key_const_reference, metadata_value_const_reference>;

    SPARROW_API int32_t extract_int32(const char*& ptr);
 
    class key_value_view;

    class key_value_view_iterator
    {
    public:
 
        using iterator_category = std::forward_iterator_tag;
 
        key_value_view_iterator()
            : m_parent(nullptr)
            , m_index(0)
            , m_current(nullptr)
            , m_key()
            , m_value()
        {
        }
 
        using value_type = metadata_pair_const_reference;
        using difference_type = std::ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;
        using iterator_concept = std::forward_iterator_tag;
 

        SPARROW_API key_value_view_iterator(const key_value_view& parent, int32_t index);

        SPARROW_API value_type operator*() const;

        SPARROW_API key_value_view_iterator& operator++();

        SPARROW_API key_value_view_iterator operator++(int);

        friend bool operator==(const key_value_view_iterator& lhs, const key_value_view_iterator& rhs)
        {
            return lhs.m_index == rhs.m_index;
        }
 
    private:

        SPARROW_API std::string_view extract_string_view();

        SPARROW_API void extract_key_value();
 
        const key_value_view* m_parent;  
        int32_t m_index;                 
        const char* m_current;           
        std::string_view m_key;          
        std::string_view m_value;        
    };

    class key_value_view : public std::ranges::view_interface<key_value_view>
    {
    public:

        SPARROW_API key_value_view(const char* ptr);

        [[nodiscard]] SPARROW_API key_value_view_iterator cbegin() const;

        [[nodiscard]] SPARROW_API key_value_view_iterator begin() const;

        [[nodiscard]] SPARROW_API key_value_view_iterator cend() const;

        [[nodiscard]] SPARROW_API key_value_view_iterator end() const;

        [[nodiscard]] SPARROW_API size_t size() const;
 
        [[nodiscard]] SPARROW_API bool empty() const;
 
        [[nodiscard]] SPARROW_API key_value_view_iterator find(std::string_view key) const;
 
    private:
 
        const char* m_ptr;        
        int32_t m_num_pairs = 0;  
 
        friend key_value_view_iterator;
    };

    SPARROW_API bool operator==(const sparrow::key_value_view& lhs, const sparrow::key_value_view& rhs);

    template <typename T>
    concept input_metadata_container = (std::ranges::input_range<T>
                                        && std::same_as<std::ranges::range_value_t<T>, metadata_pair>)
                                       || std::same_as<T, key_value_view>;

    template <input_metadata_container T>
    std::string get_metadata_from_key_values(const T& metadata)
    {
        // Check that the number of key-value pairs fits in int32_t
        SPARROW_ASSERT_TRUE(std::cmp_less(metadata.size(), std::numeric_limits<int32_t>::max()));
        const auto number_of_key_values = static_cast<int32_t>(metadata.size());
 
        const size_t metadata_size = std::accumulate(
            metadata.cbegin(),
            metadata.cend(),
            size_t(0),
            [](size_t acc, const auto& pair)
            {
                return acc + sizeof(int32_t)  // byte length of key
                       + pair.first.size()    // number of bytes of key
                       + sizeof(int32_t)      // byte length of value
                       + pair.second.size();  // number of bytes of value
            }
        );
        const size_t total_size = sizeof(int32_t) + metadata_size;
        std::string metadata_buf(total_size, '\0');
 
        // Use iterators instead of pointer arithmetic to avoid warnings
        auto metadata_iter = metadata_buf.begin();
        std::memcpy(&(*metadata_iter), &number_of_key_values, sizeof(int32_t));
        std::advance(metadata_iter, sizeof(int32_t));
 
        for (const auto& [key, value] : metadata)
        {
            SPARROW_ASSERT_TRUE(std::cmp_less(key.size(), std::numeric_limits<int32_t>::max()));
            SPARROW_ASSERT_TRUE(std::cmp_less(value.size(), std::numeric_limits<int32_t>::max()));
 
            const auto key_size = static_cast<int32_t>(key.size());
            std::memcpy(&(*metadata_iter), &key_size, sizeof(int32_t));
            std::advance(metadata_iter, sizeof(int32_t));
 
            sparrow::ranges::copy(key, &(*metadata_iter));
            std::advance(metadata_iter, key.size());
 
            const auto value_size = static_cast<int32_t>(value.size());
            std::memcpy(&(*metadata_iter), &value_size, sizeof(int32_t));
            std::advance(metadata_iter, sizeof(int32_t));
 
            sparrow::ranges::copy(value, &(*metadata_iter));
            std::advance(metadata_iter, value.size());
        }
        return metadata_buf;
    }
}
 
 
#if defined(__cpp_lib_format)
 
 
template <>
struct std::formatter<sparrow::key_value_view>
{
    constexpr auto parse(std::format_parse_context& ctx)
    {
        return ctx.begin();  // Simple implementation
    }
 
    auto format(const sparrow::key_value_view& array, std::format_context& ctx) const
    {
        auto out = ctx.out();
        *out++ = '<';
 
        bool first = true;
        for (const auto& elem : array)
        {
            if (!first)
            {
                *out++ = ',';
                *out++ = ' ';
            }
            out = std::format_to(out, "({}:{})", elem.first, elem.second);
            first = false;
        }
 
        *out++ = '>';
        return out;
    }
};
 
namespace sparrow
{
    inline std::ostream& operator<<(std::ostream& os, const key_value_view& value)
    {
        os << std::format("{}", value);
        return os;
    }
}
 
#endif