bits/binders.h

// Implementation of std::move_only_function, std::copyable_function
// and std::function_ref  -*- C++ -*-
 
// Copyright The GNU Toolchain Authors.
//
// This file is part of the GNU ISO C++ Library.  This library 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, or (at your option)
// any later version.
 
// This library 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.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.
 
/** @file include/bits/binder.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{functional}
 */
 
#ifndef _GLIBCXX_BINDERS_H
#define _GLIBCXX_BINDERS_H 1
 
#ifdef _GLIBCXX_SYSHDR
#pragma GCC system_header
#endif
 
#if __cplusplus >= 202002L
 
#include <bits/invoke.h>
#include <bits/move.h>
 
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
 
  template<size_t, typename _Tp>
    struct _Indexed_bound_arg
    {
      [[no_unique_address]] _Tp _M_val;
    };
 
  template<typename... _IndexedArgs>
    struct _Bound_arg_storage : _IndexedArgs...
    {
      template<bool _Back, typename _Fd, typename _Self, typename... _CallArgs>
        static constexpr
        decltype(auto)
        _S_apply(_Fd&& __fd, _Self&& __self, _CallArgs&&... __call_args)
        {
          if constexpr (_Back)
            return std::__invoke(std::forward<_Fd>(__fd),
                                 std::forward<_CallArgs>(__call_args)...,
                                 __like_t<_Self, _IndexedArgs>(__self)._M_val...);
          else
            return std::__invoke(std::forward<_Fd>(__fd),
                                 __like_t<_Self, _IndexedArgs>(__self)._M_val...,
                                 std::forward<_CallArgs>(__call_args)...);
        }
    };
 
  template<typename... _BoundArgs, typename... _Args>
    constexpr auto
    __make_bound_args(_Args&&... __args)
    {
      if constexpr (sizeof...(_BoundArgs) == 1)
        // pack has one element, so return copy of arg
        return (_BoundArgs(std::forward<_Args>(__args)), ...);
      else
        {
          auto __impl = [&]<size_t... _Inds>(index_sequence<_Inds...>)
          {
            return _Bound_arg_storage<_Indexed_bound_arg<_Inds, _BoundArgs>...>
                   { {_BoundArgs(std::forward<_Args>(__args))}... };
          };
          return __impl(index_sequence_for<_BoundArgs...>());
        }
    }
 
  template<bool _Back, typename _Fd, typename... _BoundArgs>
    class _Binder
    {
      template<typename _Self, typename... _CallArgs>
        using _Result_t = __conditional_t<
          _Back,
          invoke_result<__like_t<_Self, _Fd>,
                        _CallArgs..., __like_t<_Self, _BoundArgs>...>,
          invoke_result<__like_t<_Self, _Fd>,
                        __like_t<_Self, _BoundArgs>..., _CallArgs...>>::type;
 
      template<typename _Self, typename... _CallArgs>
        static consteval bool
        _S_noexcept_invocable()
        {
          if constexpr (_Back)
            return is_nothrow_invocable_v< __like_t<_Self, _Fd>,
                     _CallArgs..., __like_t<_Self, _BoundArgs>...>;
          else
            return is_nothrow_invocable_v<__like_t<_Self, _Fd>,
                     __like_t<_Self, _BoundArgs>..., _CallArgs...>;
        }
 
    public:
      static_assert(is_move_constructible_v<_Fd>);
      static_assert((is_move_constructible_v<_BoundArgs> && ...));
 
      // First parameter is to ensure this constructor is never used
      // instead of the copy/move constructor.
      template<typename _Fn, typename... _Args>
        explicit constexpr
        _Binder(int, _Fn&& __fn, _Args&&... __args)
        noexcept(__and_<is_nothrow_constructible<_Fd, _Fn>,
                        is_nothrow_constructible<_BoundArgs, _Args>...>::value)
        : _M_fd(std::forward<_Fn>(__fn)),
          _M_bound_args(__make_bound_args<_BoundArgs...>(std::forward<_Args>(__args)...))
        { static_assert(sizeof...(_Args) == sizeof...(_BoundArgs)); }
 
#if _GLIBCXX_EXPLICIT_THIS_PARAMETER
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wc++23-extensions" // deducing this
      template<typename _Self, typename... _CallArgs>
        constexpr _Result_t<_Self, _CallArgs...>
        operator()(this _Self&& __self, _CallArgs&&... __call_args)
        noexcept(_S_noexcept_invocable<_Self, _CallArgs...>())
        {
          return _S_call(__like_t<_Self, _Binder>(__self),
                         std::forward<_CallArgs>(__call_args)...);
        }
# pragma GCC diagnostic pop
#else
      template<typename... _CallArgs>
        requires true
        constexpr _Result_t<_Binder&, _CallArgs...>
        operator()(_CallArgs&&... __call_args) &
        noexcept(_S_noexcept_invocable<_Binder&, _CallArgs...>())
        {
          return _S_call(*this, std::forward<_CallArgs>(__call_args)...);
        }
 
      template<typename... _CallArgs>
        requires true
        constexpr _Result_t<const _Binder&, _CallArgs...>
        operator()(_CallArgs&&... __call_args) const &
        noexcept(_S_noexcept_invocable<const _Binder&, _CallArgs...>())
        {
          return _S_call(*this, std::forward<_CallArgs>(__call_args)...);
        }
 
      template<typename... _CallArgs>
        requires true
        constexpr _Result_t<_Binder&&, _CallArgs...>
        operator()(_CallArgs&&... __call_args) &&
        noexcept(_S_noexcept_invocable<_Binder&&, _CallArgs...>())
        {
          return _S_call(std::move(*this),
                         std::forward<_CallArgs>(__call_args)...);
        }
 
      template<typename... _CallArgs>
        requires true
        constexpr _Result_t<const _Binder&&, _CallArgs...>
        operator()(_CallArgs&&... __call_args) const &&
        noexcept(_S_noexcept_invocable<const _Binder&&, _CallArgs...>())
        {
          return _S_call(std::move(*this),
                         std::forward<_CallArgs>(__call_args)...);
        }
 
      template<typename... _CallArgs>
        void operator()(_CallArgs&&...) & = delete;
 
      template<typename... _CallArgs>
        void operator()(_CallArgs&&...) const & = delete;
 
      template<typename... _CallArgs>
        void operator()(_CallArgs&&...) && = delete;
 
      template<typename... _CallArgs>
        void operator()(_CallArgs&&...) const && = delete;
#endif
 
      template<typename _Tp, typename... _CallArgs>
        static constexpr
        decltype(auto)
        _S_call(_Tp&& __g, _CallArgs&&... __call_args)
        {
          if constexpr (sizeof...(_BoundArgs) > 1)
            return _BoundArgsStorage::template _S_apply<_Back>(
                      std::forward<_Tp>(__g)._M_fd,
                      std::forward<_Tp>(__g)._M_bound_args,
                      std::forward<_CallArgs>(__call_args)...);
          else if constexpr (sizeof...(_BoundArgs) == 0)
            return std::__invoke(std::forward<_Tp>(__g)._M_fd,
                                 std::forward<_CallArgs>(__call_args)...);
          else if constexpr (_Back) // sizeof...(_BoundArgs) == 1
            return std::__invoke(std::forward<_Tp>(__g)._M_fd,
                                 std::forward<_CallArgs>(__call_args)...,
                                 std::forward<_Tp>(__g)._M_bound_args);
          else // !_Back && sizeof...(_BoundArgs) == 1
            return std::__invoke(std::forward<_Tp>(__g)._M_fd,
                                 std::forward<_Tp>(__g)._M_bound_args,
                                 std::forward<_CallArgs>(__call_args)...);
        }
 
    private:
      using _BoundArgsStorage
        // _BoundArgs are required to be move-constructible, so this is valid.
        = decltype(__make_bound_args<_BoundArgs...>(std::declval<_BoundArgs>()...));
 
      [[no_unique_address]] _Fd _M_fd;
      [[no_unique_address]] _BoundArgsStorage _M_bound_args;
    };
 
  template<typename _Fn, typename... _Args>
    using _Bind_front_t = _Binder<false, decay_t<_Fn>, decay_t<_Args>...>;
 
  // for zero bounds args behavior of bind_front and bind_back is the same,
  // so reuse _Bind_front_t, i.e. _Binder<false, ...>
  template<typename _Fn, typename... _Args>
    using _Bind_back_t
      = _Binder<(sizeof...(_Args) > 0), decay_t<_Fn>, decay_t<_Args>...>;
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
 
#endif // __cplusplus >= 202002L
#endif // _GLIBCXX_BINDERS_H