parameter_pack.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <algorithm>
#include <AUI/Traits/concepts.h>
 
namespace aui {
    namespace impl {
        template<typename First, typename... Up>
        struct first {
            using type = First;
        };
    }
 
    namespace parameter_pack {
        template<typename Callable, typename... Args>
        static void for_each(Callable&& c, Args&&... args) requires (... && aui::invocable<Callable, Args>) {
            (..., [&] {
                c(std::forward<Args>(args));
            }());
        }
 
        template<typename... Types>
        using first = typename impl::first<Types...>::type;
    };
 
    template<typename... Args>
    struct tuple_visitor;
 
    template<typename... Args>
    struct tuple_visitor<std::tuple<Args...>> {
 
        template<typename Callable>
        static void for_each_single(Callable&& c) {
            (..., c.template operator()<Args>());
        }
 
        template<typename Callable>
        static auto for_each_all(Callable&& c) {
            return c.template operator()<Args...>();
        }
 
        template<typename Callable>
        static auto for_each_make_tuple(Callable&& c) {
            return for_each_make_tuple_impl<Callable&&, Args...>(std::forward<Callable>(c));
        }
 
    private:
        template<typename Callable, typename First, typename... Remaining>
        static auto for_each_make_tuple_impl(Callable&& c) {
            auto x = c.template operator()<First>();
            return std::tuple_cat(std::make_tuple(std::move(x)),
                                  for_each_make_tuple_impl<Callable&&, Remaining...>(std::forward<Callable>(c)));
        }
        template<typename Callable>
        static auto for_each_make_tuple_impl(Callable&& c) {
            return std::make_tuple();
        }
    };
}