list_value.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 <ostream>
 
#include "sparrow/config/config.hpp"
#include "sparrow/layout/array_helper.hpp"
#include "sparrow/types/data_traits.hpp"
#include "sparrow/utils/iterator.hpp"
#include "sparrow/utils/nullable.hpp"
 
namespace sparrow
{
    class array;
 
    class list_value;
 
    template <class L>
    class list_reference;

    class SPARROW_API list_value_iterator : public pointer_index_iterator_base<
                                                list_value_iterator,
                                                const array,
                                                array_traits::const_reference,
                                                array_traits::const_reference,
                                                std::random_access_iterator_tag>
    {
    public:
 
        using self_type = list_value_iterator;
        using base_type = pointer_index_iterator_base<
            list_value_iterator,
            const array,
            array_traits::const_reference,
            array_traits::const_reference,
            std::random_access_iterator_tag>;
        using size_type = size_t;

        list_value_iterator() noexcept = default;

        list_value_iterator(const array* flat_array, size_type index);
 
    private:
 
        [[nodiscard]] reference dereference() const;
 
        friend class iterator_access;
    };

    class SPARROW_API list_value
    {
    public:
 
        using value_type = array_traits::value_type;
        using const_reference = array_traits::const_reference;
        using size_type = std::size_t;
        using list_value_reverse_iterator = std::reverse_iterator<list_value_iterator>;

        list_value() = default;

        list_value(const array* flat_array, size_type index_begin, size_type index_end);

        [[nodiscard]] size_type size() const;

        [[nodiscard]] bool empty() const;

        const_reference operator[](size_type i) const;

        [[nodiscard]] const_reference front() const;

        [[nodiscard]] const_reference back() const;

        [[nodiscard]] list_value_iterator begin();

        [[nodiscard]] list_value_iterator begin() const;

        [[nodiscard]] list_value_iterator cbegin() const;

        [[nodiscard]] list_value_iterator end();

        [[nodiscard]] list_value_iterator end() const;

        [[nodiscard]] list_value_iterator cend() const;

        [[nodiscard]] list_value_reverse_iterator rbegin();

        [[nodiscard]] list_value_reverse_iterator rbegin() const;

        [[nodiscard]] list_value_reverse_iterator crbegin() const;

        [[nodiscard]] list_value_reverse_iterator rend();

        [[nodiscard]] list_value_reverse_iterator rend() const;

        [[nodiscard]] list_value_reverse_iterator crend() const;
 
    private:

        [[nodiscard]] const array* flat_array() const noexcept
        {
            return p_flat_array;
        }

        [[nodiscard]] size_type begin_index() const noexcept
        {
            return m_index_begin;
        }

        [[nodiscard]] size_type end_index() const noexcept
        {
            return m_index_end;
        }
 
        const array* p_flat_array = nullptr;  
        size_type m_index_begin = 0u;         
        size_type m_index_end = 0u;           
 
 
        template <bool BIG>
        friend class list_array_impl;
 
        template <bool BIG>
        friend class list_view_array_impl;
 
        friend class fixed_sized_list_array;
 
        template <class DERIVED>
        friend class list_array_crtp_base;
    };
 
    SPARROW_API bool operator==(const list_value& lhs, const list_value& rhs);
 
    template <class L>
    class list_reference
    {
    public:
 
        using self_type = list_reference<L>;
        using value_type = list_value;
        using size_type = list_value::size_type;
        using iterator = list_value_iterator;
        using const_iterator = list_value_iterator;
 
        constexpr list_reference(L* layout, size_type index)
            : p_layout(layout)
            , m_index(index)
        {
        }
 
        constexpr list_reference(const self_type&) noexcept = default;
        constexpr list_reference(self_type&&) noexcept = default;
        ~list_reference() = default;
 
        self_type& operator=(const list_value& rhs)
        {
            p_layout->replace_value(m_index, rhs);
            return *this;
        }
 
        self_type& operator=(const self_type& rhs)
        {
            return operator=(static_cast<list_value>(rhs));
        }
 
        self_type& operator=(self_type&& rhs)
        {
            return operator=(static_cast<list_value>(rhs));
        }
 
        operator list_value() const noexcept
        {
            const auto [b, e] = p_layout->offset_range(m_index);
            return list_value(p_layout->raw_flat_array(), static_cast<size_type>(b), static_cast<size_type>(e));
        }
 
        [[nodiscard]] size_type size() const noexcept
        {
            return view().size();
        }
 
        [[nodiscard]] bool empty() const noexcept
        {
            return view().empty();
        }
 
        [[nodiscard]] auto operator[](size_type i) const
        {
            return view()[i];
        }
 
        [[nodiscard]] auto front() const
        {
            return view().front();
        }
 
        [[nodiscard]] auto back() const
        {
            return view().back();
        }
 
        [[nodiscard]] iterator begin() const
        {
            return view().begin();
        }
 
        [[nodiscard]] iterator end() const
        {
            return view().end();
        }
 
        [[nodiscard]] iterator cbegin() const
        {
            return view().cbegin();
        }
 
        [[nodiscard]] iterator cend() const
        {
            return view().cend();
        }
 
        [[nodiscard]] bool operator==(const list_value& rhs) const
        {
            return view() == rhs;
        }
 
        [[nodiscard]] bool operator==(const self_type& rhs) const
        {
            return view() == rhs.view();
        }
 
    private:
 
        [[nodiscard]] list_value view() const noexcept
        {
            return static_cast<list_value>(*this);
        }
 
        L* p_layout = nullptr;
        size_type m_index = 0;
    };

    SPARROW_API
    bool operator==(const list_value& lhs, const list_value& rhs);
}
 
#if defined(__cpp_lib_format)
 
template <>
struct std::formatter<sparrow::list_value>
{
    constexpr auto parse(std::format_parse_context& ctx) -> decltype(ctx.begin())
    {
        return ctx.begin();  // Simple implementation
    }
 
    SPARROW_API auto format(const sparrow::list_value& list_value, std::format_context& ctx) const
        -> decltype(ctx.out());
};
 
namespace sparrow
{
    SPARROW_API std::ostream& operator<<(std::ostream& os, const list_value& value);
}
 
#endif