vtag.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <numeric>
#include <tuple>
#include <type_traits>
 
#include <bio/core.hpp>
#include <bio/meta/concept/core_language.hpp>
#include <bio/ranges/container/small_string.hpp>
 
namespace bio::meta::detail
{
 
template <size_t capacity>
struct literal_buffer_string : ranges::small_string<capacity>
{
    template <size_t N>
    constexpr literal_buffer_string(char const (&_lit)[N]) noexcept : ranges::small_string<capacity>{_lit}
    {}
};
 
template <size_t N>
literal_buffer_string(char const (&)[N]) -> literal_buffer_string<N - 1>;
 
} // namespace bio::meta::detail
 
namespace bio::meta
{
 
template <auto... vs>
struct vtag_t;
 
template <>
struct vtag_t<>
{
    static constexpr size_t size = 0;
 
    static constexpr auto as_tuple = std::tuple{};
 
    static consteval bool contains(auto &&) { return false; }
 
    static consteval size_t index_of(auto &&) { return static_cast<size_t>(-1ULL); }
 
    consteval friend bool operator==(vtag_t, vtag_t) noexcept { return true; }
 
    consteval friend auto operator<=>(vtag_t, vtag_t) noexcept { return 0 <=> 0; }
};
 
template <auto v>
struct vtag_t<v>
{
    static constexpr auto value = v;
 
    static constexpr size_t size = 1;
 
    static constexpr auto as_tuple = std::tuple{v};
 
    static consteval bool contains(auto && s)
        requires(weakly_equality_comparable_with<decltype(s), decltype(v)>)
    {
        return s == v;
    }
 
    static consteval size_t index_of(auto && s)
        requires(weakly_equality_comparable_with<decltype(s), decltype(v)>)
    {
        return (s == v) ? 0ull : static_cast<size_t>(-1ull);
    }
 
    consteval auto operator-()
        requires(arithmetic<decltype(v)>)
    {
        return vtag_t<-v>{};
    }
 
    template <auto v2>
    consteval friend bool operator==(vtag_t, vtag_t<v2>) noexcept
        requires weakly_equality_comparable_with<decltype(v), decltype(v2)>
    {
        return v == v2;
    }
 
    template <auto v2>
    consteval friend auto operator<=>(vtag_t, vtag_t<v2>) noexcept
        requires weakly_ordered_with<decltype(v), decltype(v2)>
    {
        return v <=> v2;
    }
};
 
template <auto... vs>
    requires(sizeof...(vs) >= 2)
struct vtag_t<vs...>
{
    static constexpr size_t size = sizeof...(vs);
 
    static constexpr auto as_tuple = std::tuple{vs...};
 
    static consteval bool contains(auto && s)
        requires((weakly_equality_comparable_with<decltype(s), decltype(vs)> && ...))
    {
        return ((s == vs) || ...);
    }
 
    static consteval size_t index_of(auto && s)
        requires((weakly_equality_comparable_with<decltype(s), decltype(vs)> && ...))
    {
        size_t c = 0;
        ((vs != s && ++c) && ...);
        return c >= size ? static_cast<size_t>(-1ULL) : c;
    }
 
    template <auto... v2s>
    consteval friend bool operator==(vtag_t, vtag_t<v2s...>) noexcept
        requires(sizeof...(v2s) == size && (weakly_equality_comparable_with<decltype(vs), decltype(v2s)> && ...))
    {
        return vtag_t::as_tuple == vtag_t<v2s...>::as_tuple;
    }
 
    template <auto... v2s>
    consteval friend auto operator<=>(vtag_t, vtag_t<v2s...>) noexcept
        requires(sizeof...(v2s) == size && (weakly_ordered_with<decltype(vs), decltype(v2s)> && ...))
    {
        return vtag_t::as_tuple <=> vtag_t<v2s...>::as_tuple;
    }
};
 
template <auto... vs>
inline constexpr vtag_t<vs...> vtag{};
 
inline namespace literals
{
 
template <detail::literal_buffer_string str>
consteval auto operator""_vtag() noexcept
{
    return vtag<ranges::small_string<str.size()>{str}>;
}
 
template <char... chrs>
consteval auto operator""_vtag() noexcept
{
    static_assert(((chrs >= '0' && chrs <= '9') && ...), "Only integral digits supported.");
 
    constexpr int64_t val = []() constexpr
    {
        ranges::small_string str{chrs...};
        int64_t              ret  = 0;
        int64_t              mult = 1;
        // std::views::reverse is not constexpr on GCC10 :|
        for (int64_t i = str.size() - 1; i >= 0; --i)
        {
            ret += (str[i] - '0') * mult;
            mult *= 10;
        }
        return ret;
    }();
    return vtag<val>;
}
 
} // namespace literals
 
} // namespace bio::meta