#pragma once /* * Copyright (C) 2024 Brett Terpstra * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #ifndef BLT_GP_OPERATIONS_H #define BLT_GP_OPERATIONS_H #include #include #include #include #include #include namespace blt::gp { namespace detail { template using remove_cv_ref = std::remove_cv_t>; template struct first_arg; template struct first_arg { using type = First; }; template<> struct first_arg<> { using type = void; }; template struct is_same; template struct is_same : public std::false_type { }; template struct is_same : public std::is_same { }; template constexpr bool is_same_v = is_same::value; struct empty_t { }; } template struct call_with { template [[nodiscard]] inline constexpr static blt::size_t getByteOffset() { blt::size_t offset = 0; blt::size_t current_index = 0; ((offset += (current_index++ > index ? stack_allocator::aligned_size>() : 0)), ...); // BLT_INFO("offset %ld for argument %ld", offset, index); return offset; } template void print_args(std::integer_sequence) { BLT_INFO("Arguments:"); (BLT_INFO("%ld: %s", indices, blt::type_string().c_str()), ...); } template inline static constexpr Return exec_sequence_to_indices(Func&& func, stack_allocator& allocator, std::integer_sequence, ExtraArgs&& ... args) { //blt::size_t arg_size = (stack_allocator::aligned_size>() + ...); //BLT_TRACE(arg_size); // expands Args and indices, providing each argument with its index calculating the current argument byte offset return std::forward(func)(std::forward(args)..., allocator.from>(getByteOffset())...); } template Return operator()(Func&& func, stack_allocator& read_allocator, ExtraArgs&& ... args) { constexpr auto seq = std::make_integer_sequence(); #if BLT_DEBUG_LEVEL > 0 try { #endif Return ret = exec_sequence_to_indices(std::forward(func), read_allocator, seq, std::forward(args)...); read_allocator.call_destructors...>(); read_allocator.pop_bytes((stack_allocator::aligned_size>() + ...)); return ret; #if BLT_DEBUG_LEVEL > 0 } catch (const std::runtime_error& e) { print_args(seq); throw std::runtime_error(e.what()); } #endif } }; template struct call_without_first : public call_with { using call_with::call_with; }; template class operation_t; template class operation_t { public: using function_t = ArgType; constexpr operation_t(const operation_t& copy) = default; constexpr operation_t(operation_t&& move) = default; template constexpr explicit operation_t(const Functor& functor, std::optional name = {}): func(functor), name(name) {} [[nodiscard]] constexpr inline Return operator()(stack_allocator& read_allocator) const { if constexpr (sizeof...(Args) == 0) { return func(); } else { return call_with()(func, read_allocator); } } [[nodiscard]] constexpr inline Return operator()(void* context, stack_allocator& read_allocator) const { // should be an impossible state if constexpr (sizeof...(Args) == 0) { BLT_ABORT("Cannot pass context to function without arguments!"); } auto& ctx_ref = *static_cast::type>*>(context); if constexpr (sizeof...(Args) == 1) { return func(ctx_ref); } else { return call_without_first()(func, read_allocator, ctx_ref); } } template [[nodiscard]] detail::callable_t make_callable() const { return [this](void* context, stack_allocator& read_allocator, stack_allocator& write_allocator) { if constexpr (detail::is_same_v::type>>) { // first arg is context write_allocator.push(std::move(this->operator()(context, read_allocator))); } else { // first arg isn't context write_allocator.push(std::move(this->operator()(read_allocator))); } }; } [[nodiscard]] inline constexpr std::optional get_name() const { return name; } inline constexpr const auto& get_function() const { return func; } operator_id id = -1; private: function_t func; std::optional name; }; template class operation_t : public operation_t { public: using operation_t::operation_t; }; template operation_t(Lambda) -> operation_t; template operation_t(Return(*)(Args...)) -> operation_t; template operation_t(Lambda, std::optional) -> operation_t; template operation_t(Return(*)(Args...), std::optional) -> operation_t; } #endif //BLT_GP_OPERATIONS_H