cpputil/variant_visit.hpp at master · cpplearner/cpputil · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
#pragma once

#include <variant>
#include <type_traits>
#include <utility>

#include "invoke.hpp"

template<class Visitor, class Variant>
constexpr decltype(auto) variant_visit(Visitor&& vis, Variant&& var) {
    constexpr auto size = std::variant_size_v<std::decay_t<Variant>>;
    using R = std::invoke_result_t<Visitor,
        decltype(std::get<0>(std::declval<Variant>()))>;
    auto f = [&vis, &var, index = var.index()](auto&& rec, auto i) -> R {
        // [[assert: &rec == &f]];
        static_assert(0 <= i && i <= size);
        if constexpr (i == size)
            throw std::bad_variant_access();
        else {
            static_assert(std::is_same_v<R, std::invoke_result_t<Visitor,
                decltype(std::get<i>(std::declval<Variant>()))>>,
                "visitor must return the same type for all alternatives!");
            if (i == index)
                return (invoke)(static_cast<Visitor&&>(vis),
                    std::get<i>(static_cast<Variant&&>(var)));
            else
                return rec(rec, std::integral_constant<std::size_t, i + 1>{});
        }
    };
    return f(f, std::integral_constant<std::size_t, 0>{});
}

template<class T, std::size_t> struct wrapper { T elem; };
template<class... Args> struct tuple : Args... {};

template<class I, class Visitor, class... Ts, std::size_t... Is>
constexpr decltype(auto) visit_impl(I, Visitor&& vis,
    tuple<wrapper<Ts, Is>...> tpl)
{
    return static_cast<Visitor&&>(vis)(
        static_cast<wrapper<Ts, Is>&>(tpl).elem...);
}

template<class I, class Visitor, class... Ts, std::size_t... Is,
    class Variant, class... Variants>
constexpr decltype(auto) visit_impl(I, Visitor&& vis,
    tuple<wrapper<Ts, Is>...> tpl, Variant&& var, Variants&&... vars)
{
    auto f = [&vis, &tpl, &vars...](auto&& cur) -> decltype(auto) {
        using T = decltype(cur);
        return (visit_impl)(std::integral_constant<std::size_t, I::value + 1>{},
            static_cast<Visitor&&>(vis),
            tuple<wrapper<Ts, Is>..., wrapper<T, I::value>>{
                static_cast<wrapper<Ts, Is>&>(tpl)..., { static_cast<T>(cur) }
            },
            static_cast<Variants&&>(vars)...);
    };
    return (variant_visit)(f, static_cast<Variant&&>(var));
}

template<class Visitor, class Variant, class... Variants>
constexpr decltype(auto) variant_visit(Visitor&& vis, Variant&& var,
    Variants&&... vars)
{
    return (visit_impl)(std::integral_constant<std::size_t, 0>{},
        static_cast<Visitor&&>(vis), tuple<>{},
        static_cast<Variant&&>(var), static_cast<Variants&&>(vars)...);
}