ContainerTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <memory>
#include <type_traits>
 
namespace BaseLib
{
namespace detail
{
 
template <typename Element>
struct PolymorphicRandomAccessContainerViewInterface;
 
template <typename Element>
struct PolymorphicRandomAccessContainerViewIterator
{
    using value_type = Element;
    using difference_type = std::ptrdiff_t;
 
    PolymorphicRandomAccessContainerViewIterator() = default;
 
    PolymorphicRandomAccessContainerViewIterator(
        std::size_t n,
        PolymorphicRandomAccessContainerViewInterface<Element> const* const
            view) noexcept
        : n_{n}, view_{view}
    {
    }
 
    PolymorphicRandomAccessContainerViewIterator& operator++() noexcept
    {
        ++n_;
        return *this;
    }
    PolymorphicRandomAccessContainerViewIterator operator++(int) noexcept
    {
        auto copy{*this};
        operator++();
        return copy;
    }
 
    PolymorphicRandomAccessContainerViewIterator& operator--() noexcept
    {
        --n_;
        return *this;
    }
    PolymorphicRandomAccessContainerViewIterator operator--(int) noexcept
    {
        auto copy{*this};
        operator--();
        return copy;
    }
 
    PolymorphicRandomAccessContainerViewIterator& operator+=(
        difference_type const increment) noexcept
    {
        n_ += increment;
        return *this;
    }
    PolymorphicRandomAccessContainerViewIterator& operator-=(
        difference_type const decrement) noexcept
    {
        n_ -= decrement;
        return *this;
    }
 
    [[nodiscard]] friend PolymorphicRandomAccessContainerViewIterator operator+(
        PolymorphicRandomAccessContainerViewIterator iterator,
        difference_type const increment) noexcept
    {
        iterator.n_ += increment;
        return iterator;
    }
 
    [[nodiscard]] friend PolymorphicRandomAccessContainerViewIterator operator+(
        difference_type const increment,
        PolymorphicRandomAccessContainerViewIterator iterator) noexcept
    {
        iterator.n_ += increment;
        return iterator;
    }
 
    [[nodiscard]] difference_type operator-(
        PolymorphicRandomAccessContainerViewIterator const other) const noexcept
    {
        assert(view_ == other.view_);
        return n_ - other.n_;
    }
 
    [[nodiscard]] friend PolymorphicRandomAccessContainerViewIterator operator-(
        PolymorphicRandomAccessContainerViewIterator iterator,
        difference_type const decrement) noexcept
    {
        iterator.n_ -= decrement;
        return iterator;
    }
 
    [[nodiscard]] Element& operator*() const { return (*view_)[n_]; }
    [[nodiscard]] Element& operator[](difference_type n) const
    {
        return (*view_)[n_ + n];
    }
 
    auto operator<=>(
        PolymorphicRandomAccessContainerViewIterator const&) const = default;
 
private:
    std::size_t n_ = 0;
    PolymorphicRandomAccessContainerViewInterface<Element> const* view_ =
        nullptr;
};
 
template <typename Element>
struct PolymorphicRandomAccessContainerViewInterface
{
    [[nodiscard]] PolymorphicRandomAccessContainerViewIterator<Element> begin()
        const noexcept
    {
        return {0, this};
    }
    [[nodiscard]] PolymorphicRandomAccessContainerViewIterator<Element> end()
        const noexcept
    {
        return {size(), this};
    }
 
    [[nodiscard]] virtual std::size_t size() const noexcept = 0;
 
    [[nodiscard]] virtual Element& operator[](std::size_t) const = 0;
 
    virtual ~PolymorphicRandomAccessContainerViewInterface() = default;
};
 
template <typename Element, typename Container>
struct CovariantRandomAccessContainerView final
    : PolymorphicRandomAccessContainerViewInterface<Element>
{
    explicit CovariantRandomAccessContainerView(Container& container)
        : container_{container}
    {
    }
 
    Element& operator[](std::size_t index) const override
    {
        if constexpr (requires {
                          typename Container::value_type::element_type;
                      })
        {
            static_assert(
                std::derived_from<typename Container::value_type::element_type,
                                  Element>);
 
            return *container_[index];
        }
        else
        {
            static_assert(
                std::derived_from<typename Container::value_type, Element>);
 
            // this restriction is necessary because of the constness
            // propagation of std::vector.
            static_assert(
                (!std::is_const_v<Container>) || std::is_const_v<Element>,
                "If the element type is non-const, the container must be "
                "non-const, too.");
 
            return container_[index];
        }
    }
 
    std::size_t size() const noexcept override { return container_.size(); }
 
private:
    Container& container_;
};
}  // namespace detail

template <typename Element>
struct PolymorphicRandomAccessContainerView
{
    PolymorphicRandomAccessContainerView(
        PolymorphicRandomAccessContainerView const&) = delete;
    PolymorphicRandomAccessContainerView(
        PolymorphicRandomAccessContainerView&&) = default;
 
    template <typename Container>
    explicit(false)
        // cppcheck-suppress noExplicitConstructor
        PolymorphicRandomAccessContainerView(Container& container)
        : impl_{std::make_unique<
              detail::CovariantRandomAccessContainerView<Element, Container>>(
              container)}
    {
    }
 
    template <typename Container>
    explicit(false)
        // cppcheck-suppress noExplicitConstructor
        PolymorphicRandomAccessContainerView(Container const& container)
        : impl_{std::make_unique<
              detail::CovariantRandomAccessContainerView<Element,
                                                         Container const>>(
              container)}
    {
    }
 
    PolymorphicRandomAccessContainerView& operator=(
        PolymorphicRandomAccessContainerView const&) = delete;
    PolymorphicRandomAccessContainerView& operator=(
        PolymorphicRandomAccessContainerView&&) = default;
 
    [[nodiscard]] detail::PolymorphicRandomAccessContainerViewIterator<Element>
    begin() const noexcept
    {
        return impl_->begin();
    }
    [[nodiscard]] detail::PolymorphicRandomAccessContainerViewIterator<Element>
    end() const noexcept
    {
        return impl_->end();
    }
 
    [[nodiscard]] std::size_t size() const noexcept { return impl_->size(); }
 
    [[nodiscard]] Element& operator[](std::size_t n) const
    {
        return (*impl_)[n];
    }
 
private:
    std::unique_ptr<
        detail::PolymorphicRandomAccessContainerViewInterface<Element>>
        impl_;
};
}  // namespace BaseLib