RecordCoord.hpp

Go to the documentation of this file.

// Copyright 2022 Alexander Matthes, Bernhard Manfred Gruber
// SPDX-License-Identifier: MPL-2.0
 
#pragma once
 
#include "Meta.hpp"
#include "macros.hpp"
 
#include <array>
#include <ostream>
#include <type_traits>
 
namespace llama
{
    LLAMA_EXPORT
    template<std::size_t... Coords>
    struct RecordCoord
    {
        using List = mp_list_c<std::size_t, Coords...>;
 
        static constexpr std::size_t front = mp_front<List>::value;
        static constexpr std::size_t back = mp_back<List>::value;
        static constexpr std::size_t size = sizeof...(Coords);
    };
 
    LLAMA_EXPORT
    template<>
    struct RecordCoord<>
    {
        using List = mp_list_c<std::size_t>;
 
        static constexpr std::size_t size = 0;
    };
 
    LLAMA_EXPORT
    template<std::size_t... CoordsA, std::size_t... CoordsB>
    LLAMA_FN_HOST_ACC_INLINE constexpr auto operator==(RecordCoord<CoordsA...>, RecordCoord<CoordsB...>)
    {
        return false;
    }
 
    LLAMA_EXPORT
    template<std::size_t... Coords>
    LLAMA_FN_HOST_ACC_INLINE constexpr auto operator==(RecordCoord<Coords...>, RecordCoord<Coords...>)
    {
        return true;
    }
 
    LLAMA_EXPORT
    template<std::size_t... CoordsA, std::size_t... CoordsB>
    LLAMA_FN_HOST_ACC_INLINE constexpr auto operator!=(RecordCoord<CoordsA...> a, RecordCoord<CoordsB...> b)
    {
        return !(a == b);
    }
 
    LLAMA_EXPORT
    template<typename T>
    inline constexpr bool isRecordCoord = false;
 
    LLAMA_EXPORT
    template<std::size_t... Coords>
    inline constexpr bool isRecordCoord<RecordCoord<Coords...>> = true;
 
    LLAMA_EXPORT
    template<std::size_t... RCs>
    auto operator<<(std::ostream& os, RecordCoord<RCs...>) -> std::ostream&
    {
        os << "RecordCoord<";
        bool first = true;
        for(auto rc : std::array<std::size_t, sizeof...(RCs)>{RCs...})
        {
            if(first)
                first = false;
            else
                os << ", ";
            os << rc;
        }
        os << ">";
        return os;
    }
 
    inline namespace literals
    {
        LLAMA_EXPORT
        template<char... Digits>
        constexpr auto operator"" _RC()
        {
            constexpr auto coord = []() constexpr
            {
                const char digits[] = {(Digits - 48)...};
                std::size_t acc = 0;
                std ::size_t powerOf10 = 1;
                for(int i = sizeof...(Digits) - 1; i >= 0; i--)
                {
                    acc += digits[i] * powerOf10;
                    powerOf10 *= 10;
                }
                return acc;
            }();
            return RecordCoord<coord>{};
        }
    } // namespace literals
 
    LLAMA_EXPORT
    template<typename L>
    using RecordCoordFromList = internal::mp_unwrap_values_into<L, RecordCoord>;
 
    LLAMA_EXPORT
    template<typename... RecordCoords>
    using Cat = RecordCoordFromList<mp_append<typename RecordCoords::List...>>;
 
    LLAMA_EXPORT
    template<typename... RecordCoords>
    LLAMA_FN_HOST_ACC_INLINE constexpr auto cat(RecordCoords...)
    {
        return Cat<RecordCoords...>{};
    }
 
    LLAMA_EXPORT
    template<typename RecordCoord>
    using PopFront = RecordCoordFromList<mp_pop_front<typename RecordCoord::List>>;
 
    namespace internal
    {
        template<std::size_t... Coords1, std::size_t... Coords2>
        constexpr auto recordCoordCommonPrefixIsBiggerImpl(RecordCoord<Coords1...>, RecordCoord<Coords2...>) -> bool
        {
            // CTAD does not work if Coords1/2 is an empty pack
            std::array<std::size_t, sizeof...(Coords1)> a1{Coords1...};
            std::array<std::size_t, sizeof...(Coords2)> a2{Coords2...};
            for(std::size_t i = 0; i < std::min(a1.size(), a2.size()); i++)
            {
                if(a1[i] > a2[i])
                    return true;
                if(a1[i] < a2[i])
                    return false;
            }
            return false;
        };
    } // namespace internal
 
    LLAMA_EXPORT
    template<typename First, typename Second>
    inline constexpr auto recordCoordCommonPrefixIsBigger
        = internal::recordCoordCommonPrefixIsBiggerImpl(First{}, Second{});
 
    namespace internal
    {
        template<std::size_t... Coords1, std::size_t... Coords2>
        constexpr auto recordCoordCommonPrefixIsSameImpl(RecordCoord<Coords1...>, RecordCoord<Coords2...>) -> bool
        {
            // CTAD does not work if Coords1/2 is an empty pack
            std::array<std::size_t, sizeof...(Coords1)> a1{Coords1...};
            std::array<std::size_t, sizeof...(Coords2)> a2{Coords2...};
            for(std::size_t i = 0; i < std::min(a1.size(), a2.size()); i++)
                if(a1[i] != a2[i])
                    return false;
            return true;
        };
    } // namespace internal
 
    LLAMA_EXPORT
    template<typename First, typename Second>
    inline constexpr auto recordCoordCommonPrefixIsSame
        = internal::recordCoordCommonPrefixIsSameImpl(First{}, Second{});
} // namespace llama