index.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* 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.
*/
#ifndef INDEX_H
#define INDEX_H
 
#include "memilio/io/io.h"
#include "memilio/utils/compiler_diagnostics.h"
#include "memilio/utils/metaprogramming.h"
#include "memilio/utils/type_safe.h"
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace mio
{
 
template <typename... CategoryTags>
class Index;
 
namespace details
{
 
template <class... T>
void is_multi_index_impl(Index<T...>);
 
} // namespace details
 
template <typename... CategoryTags>
concept IsMultiIndex = requires(Index<CategoryTags...> i) { details::is_multi_index_impl(i); };
 
namespace details
{
 
template <class... Tags>
std::tuple<Index<Tags>...> get_tuple(const Index<Tags...>& i)
{
    if constexpr (sizeof...(Tags) == 1) {
        return std::tuple(i);
    }
    else {
        return i.indices;
    }
}
 
template <class Enum>
std::tuple<Index<Enum>> get_tuple(Enum i)
    requires std::is_enum<Enum>::value
{
    return std::tuple(Index<Enum>(i));
}
 
template <class... IndexArgs>
    requires((std::is_enum_v<IndexArgs> || IsMultiIndex<IndexArgs>) && ...)
decltype(auto) concatenate_indices_impl(IndexArgs&&... args)
{
    return std::tuple_cat(details::get_tuple(args)...);
}
 
template <class... T>
Index<T...> tuple_to_index(std::tuple<Index<T>...>);
 
} // namespace details
 
template <typename CategoryTag>
class MEMILIO_ENABLE_EBO Index<CategoryTag> : public TypeSafe<size_t, Index<CategoryTag>>,
                                              public OperatorComparison<Index<CategoryTag>>,
                                              public OperatorAdditionSubtraction<Index<CategoryTag>>,
                                              public OperatorScalarMultiplicationDivision<Index<CategoryTag>, size_t>
{
public:
    using TypeSafe<size_t, Index<CategoryTag>>::TypeSafe;
 
    static constexpr size_t size         = 1;
    static constexpr bool has_duplicates = false;
 
    static constexpr Index Zero()
    {
        return Index((size_t)0);
    }
 
    Index(CategoryTag val)
        requires std::is_enum_v<CategoryTag>
        : TypeSafe<size_t, Index<CategoryTag>>((size_t)val)
    {
    }
 
    explicit Index(size_t val)
        : TypeSafe<size_t, Index<CategoryTag>>(val)
    {
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        mio::serialize(io, size_t(*this));
    }
 
    template <class IOContext>
    static IOResult<Index> deserialize(IOContext& io)
    {
        BOOST_OUTCOME_TRY(auto&& i, mio::deserialize(io, Tag<size_t>{}));
        return success(Index(i));
    }
};
 
template <typename... CategoryTag>
class Index
{
public:
    static constexpr size_t size         = sizeof...(CategoryTag);
    static constexpr bool has_duplicates = has_duplicates_v<CategoryTag...>;
 
    static Index constexpr Zero()
    {
        return Index(Index<CategoryTag>::Zero()...);
    }
 
    Index(Index<CategoryTag> const&... _indices)
        : indices{_indices...}
    {
    }
 
    template <class... IndexArgs>
        requires(sizeof...(IndexArgs) > 1)
    Index(IndexArgs&&... subindices)
        : indices(details::concatenate_indices_impl(std::forward<IndexArgs>(subindices)...))
    {
    }
 
private:
    Index(const std::tuple<Index<CategoryTag>...>& _indices)
        : indices(_indices)
    {
    }
 
public:
    // comparison operators
    bool operator==(Index const& other) const
    {
        return indices == other.indices;
    }
 
    bool operator!=(Index const& other) const
    {
        return !(this == other);
    }
 
    bool operator<(Index const& other) const
    {
        // use apply to unfold both tuples, then use a fold expression to evaluate a pairwise less
        return std::apply(
            [&other](auto&&... indices_) {
                return std::apply(
                    [&](auto&&... other_indices_) {
                        return ((indices_ < other_indices_) && ...);
                    },
                    other.indices);
            },
            indices);
    }
 
    bool operator<=(Index const& other) const
    {
        return (*this == other) || (*this < other);
    }
 
    template <class IOContext>
    void serialize(IOContext& io) const
    {
        auto obj = io.create_object("MultiIndex");
        obj.add_element("Indices", indices);
    }
 
    template <class IOContext>
    static IOResult<Index> deserialize(IOContext& io)
    {
        auto obj = io.expect_object("MultiIndex");
        auto tup = obj.expect_element("Indices", Tag<decltype(indices)>{});
        return mio::apply(
            io,
            [](auto&& tup_) {
                return Index(tup_);
            },
            tup);
    }
 
    std::tuple<Index<CategoryTag>...> indices;
};
 
template <size_t Tag, class... CategoryTags>
struct type_at_index<Tag, ::mio::Index<CategoryTags...>> : public type_at_index<Tag, CategoryTags...> {
};
 
template <class Tag, class... CategoryTags>
struct index_of_type<Tag, ::mio::Index<CategoryTags...>> : public index_of_type<Tag, CategoryTags...> {
};
 
template <class... CategoryTags>
struct index_of_type<Index<CategoryTags...>, Index<CategoryTags...>> {
    static constexpr std::size_t value = 0;
};
 
template <size_t I, typename... CategoryTags>
constexpr typename std::tuple_element<I, std::tuple<Index<CategoryTags>...>>::type&
get(Index<CategoryTags...>& i) noexcept
{
    if constexpr (sizeof...(CategoryTags) == 1) {
        static_assert(I == 0, "I must be equal to zero for an Index with just one template parameter");
        return i;
    }
    else {
        return std::get<I>(i.indices);
    }
}
 
template <size_t I, typename... CategoryTags>
constexpr typename std::tuple_element<I, std::tuple<Index<CategoryTags>...>>::type const&
get(Index<CategoryTags...> const& i) noexcept
{
    if constexpr (sizeof...(CategoryTags) == 1) {
        static_assert(I == 0, "I must be equal to zero for an Index with just one template parameter");
        return i;
    }
    else {
        return std::get<I>(i.indices);
    }
}
 
template <typename Tag, typename... CategoryTags>
constexpr Index<Tag>& get(Index<CategoryTags...>& i) noexcept
{
    if constexpr (sizeof...(CategoryTags) == 1) {
        using IndexTag = std::tuple_element_t<0, std::tuple<CategoryTags...>>;
        static_assert(std::is_same<Tag, IndexTag>::value,
                      "Tags must match for an Index with just one template parameter");
        return i;
    }
    else {
        return std::get<Index<Tag>>(i.indices);
    }
}
 
template <typename Tag, typename... CategoryTags>
constexpr Index<Tag> const& get(Index<CategoryTags...> const& i) noexcept
{
    if constexpr (sizeof...(CategoryTags) == 1) {
        using IndexTag = std::tuple_element_t<0, std::tuple<CategoryTags...>>;
        static_assert(std::is_same<Tag, IndexTag>::value,
                      "Tags must match for an Index with just one template parameter");
        return i;
    }
    else {
        return std::get<Index<Tag>>(i.indices);
    }
}
 
template <class... IndexArgs>
decltype(auto) concatenate_indices(IndexArgs&&... args)
{
    using MergedIndex =
        decltype(details::tuple_to_index(details::concatenate_indices_impl(std::declval<IndexArgs>()...)));
    return MergedIndex(std::forward<IndexArgs>(args)...);
}
 
namespace details
{
template <class... CategoryTags, class SuperIndex>
inline Index<CategoryTags...> reduce_index_impl(const SuperIndex& i, mio::Tag<Index<CategoryTags...>>)
{
    // the subindex may not be trivially constructible, so we pass its type using mio::Tag
    // the type has to be passed as an argument to determine its CategoryTags
 
    // below, we use get<index_of_type<>> instead of get<> directly to handle categories that are not unique
    // (that is, `get<CategoryTags>(i)...` fails to compile for SuperIndex=Index<T, T>)
    return Index<CategoryTags...>{get<index_of_type_v<CategoryTags, SuperIndex>>(i)...};
}
 
template <class... CategoryTags, class... Subset>
inline Index<CategoryTags...> extend_index_impl(const Index<Subset...>& i, const size_t fill_value,
                                                mio::Tag<Index<CategoryTags...>>)
{
    using SuperIndex = Index<CategoryTags...>;
    using SubIndex   = Index<Subset...>;
    // The superindex may not be trivially constructible, so we pass its type using mio::Tag.
    // The type has to be passed as an argument to determine its CategoryTags.
 
    return SuperIndex{[&]() {
        // This is an IIFE, which is invoked for each category (note the '...' after the function call).
        // So CategoryTags without a '...' is seen by each IIFE as exactly one category from this variadic template.
        if constexpr (is_type_in_list_v<CategoryTags, Subset...>) {
            // We use get<index_of_type<>> instead of get<> directly to handle categories that are not unique
            // (that is, `get<CategoryTags>(i)...` fails to compile for SuperIndex=Index<T, T>)
            return get<index_of_type_v<CategoryTags, SubIndex>>(i);
        }
        else {
            return Index<CategoryTags>(fill_value);
        }
    }()...};
}
} // namespace details
 
template <class SubIndex, class SuperIndex>
decltype(auto) reduce_index(const SuperIndex& index)
{
    if constexpr (SubIndex::size == 1 && std::is_base_of_v<Index<SubIndex>, SubIndex>) {
        // this case handles reducing from e.g. Index<AgeGroup, ...> directly to AgeGroup
        // the default case would instead reduce to Index<AgeGroup>, which may cause conversion errors
        return details::reduce_index_impl(index, mio::Tag<Index<SubIndex>>{});
    }
    else {
        return details::reduce_index_impl(index, mio::Tag<SubIndex>{});
    }
}
template <class Enum, class SuperIndex>
    requires std::is_enum_v<Enum>
Index<Enum> reduce_index(const SuperIndex& index)
{
    return details::reduce_index_impl(index, mio::Tag<Index<Enum>>{});
}
template <class SuperIndex, class SubIndex>
SuperIndex extend_index(const SubIndex& index, size_t fill_value = 0)
{
    return details::extend_index_impl(index, fill_value, mio::Tag<SuperIndex>{});
}
 
} // namespace mio
 
#endif