EIC code displayed by LXR master/​include/​boost/​compat/​move_only_function.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-08-17 08:39:22

 #ifndef BOOST_COMPAT_MOVE_ONLY_FUNCTION_HPP_INCLUDED
 #define BOOST_COMPAT_MOVE_ONLY_FUNCTION_HPP_INCLUDED
 
 // Copyright 2025 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/compat/invoke.hpp>
 #include <boost/compat/type_traits.hpp>
 #include <boost/assert.hpp>
 
 #include <cstddef>
 #include <initializer_list>
 #include <type_traits>
 
 #include <boost/config/workaround.hpp>
 
 #if BOOST_WORKAROUND(BOOST_GCC, >= 6 * 10000)
 #   pragma GCC diagnostic push
 #   pragma GCC diagnostic ignored "-Wnonnull-compare"
 #   pragma GCC diagnostic ignored "-Waddress"
 #endif
 
 namespace boost {
 namespace compat {
 
 template<class... S>
 class move_only_function;
 
 template< class T >
 struct in_place_type_t { explicit in_place_type_t() = default; };
 
 namespace detail
 {
 
 union pointers
 {
     void* pobj_;
     void ( *pfn_ )();
 };
 
 struct storage
 {
     // we want SBO to be large enough to store a type which can be used for delegation purposes
     struct delegate { void( storage::*pmfn_ )(); storage* pobj_; };
 
     union
     {
         void* pobj_;
         void ( *pfn_ )();
         alignas(delegate) unsigned char buf_[ sizeof(delegate) ];
     };
 
     template<class T>
     constexpr static bool use_sbo() noexcept
     {
         return sizeof( T ) <= sizeof( storage ) && alignof( T ) <= alignof( storage ) && std::is_nothrow_move_constructible<T>::value;
     }
 
     void* addr() noexcept
     {
         return buf_;
     }
 };
 
 template<class>
 struct is_polymorphic_function : std::false_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... )>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) &>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) &&>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const&>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const&&>> : std::true_type
 {
 };
 
 #if defined(__cpp_noexcept_function_type)
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) noexcept>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) & noexcept>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) && noexcept>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const noexcept>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const& noexcept>> : std::true_type
 {
 };
 
 template<class R, class ...Args>
 struct is_polymorphic_function<move_only_function<R( Args... ) const&& noexcept>> : std::true_type
 {
 };
 
 #endif
 
 template<class T>
 using is_move_only_function = is_polymorphic_function<T>;
 
 template<class T>
 struct is_in_place_type_t : std::false_type
 {
 };
 
 template<class T>
 struct is_in_place_type_t<in_place_type_t<T>> : std::true_type
 {
 };
 
 template<class T, class ...Args>
 struct nothrow_init
 {
     constexpr static bool const value = ( storage::use_sbo<T>() && std::is_nothrow_constructible<T, Args...>::value ) || false;
 };
 
 enum class ref_quals { none, lvalue, rvalue };
 
 template<ref_quals RQ, bool Const, bool NoEx, class VT, class R, class ...Args>
 struct is_callable_from;
 
 template<ref_quals RQ, bool Const, class VT, class R, class ...Args>
 struct is_callable_from<RQ, Const, true, VT, R, Args...>
 {
     using cv_VT = conditional_t<Const, add_const_t<VT>, VT>;
 
     using cv_ref_VT = conditional_t<
         RQ == ref_quals::none, cv_VT,
         conditional_t<
             RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_VT>, add_lvalue_reference_t<cv_VT>
         >
     >;
 
     using inv_quals_VT = conditional_t<
         RQ == ref_quals::none, add_lvalue_reference_t<cv_VT>,
         conditional_t<
             RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_VT>, add_lvalue_reference_t<cv_VT>
         >
     >;
 
     constexpr static bool const value =
         is_nothrow_invocable_r<R, cv_ref_VT, Args...>::value &&
         is_nothrow_invocable_r<R, inv_quals_VT, Args...>::value;
 };
 
 template<ref_quals RQ, bool Const, class VT, class R, class ...Args>
 struct is_callable_from<RQ, Const, false, VT, R, Args...>
 {
     using cv_VT = conditional_t<Const, add_const_t<VT>, VT>;
 
     using cv_ref_VT = conditional_t<
         RQ == ref_quals::none, cv_VT,
         conditional_t<
             RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_VT>, add_lvalue_reference_t<cv_VT>
         >
     >;
 
     using inv_quals_VT = conditional_t<
         RQ == ref_quals::none, add_lvalue_reference_t<cv_VT>,
         conditional_t<
             RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_VT>, add_lvalue_reference_t<cv_VT>
         >
     >;
 
     constexpr static bool const value =
         is_invocable_r<R, cv_ref_VT, Args...>::value &&
         is_invocable_r<R, inv_quals_VT, Args...>::value;
 };
 
 inline std::nullptr_t get_first_arg()
 {
     return nullptr;
 }
 
 template<class T, class ...CArgs>
 T&& get_first_arg( T&& t, CArgs&& ... )
 {
     return std::forward<T>( t );
 }
 
 template<class ...Ts>
 bool is_nullary_arg( Ts&&... )
 {
     return false;
 }
 
 template<
     class F, class VT = decay_t<F>,
     enable_if_t<
         std::is_member_pointer<VT>::value ||
         is_move_only_function<VT>::value,
         int> = 0
 >
 bool is_nullary_arg( F&& f )
 {
     return f == nullptr;
 }
 
 template<
     class F, class VT = decay_t<F>,
     enable_if_t<
         std::is_function<remove_pointer_t<VT>>::value,
         int> = 0
 >
 bool is_nullary_arg( F f )
 {
     return f == nullptr;
 }
 
 template<bool NoEx, class R, class ...Args>
 struct mo_invoke_function_holder
 {
     static R invoke_function( storage s, Args&&... args) noexcept( NoEx )
     {
         auto f = reinterpret_cast<R(*)( Args... )>( s.pfn_ );
         return compat::invoke_r<R>( f, std::forward<Args>( args )... );
     }
 };
 
 template<ref_quals RQ, bool Const, bool NoEx, class F, class R, class ...Args>
 struct mo_invoke_object_holder
 {
     static R invoke_object( storage s, Args&&... args ) noexcept( NoEx )
     {
         using T = remove_reference_t<F>;
         using cv_T = conditional_t<Const, add_const_t<T>, T>;
         using cv_ref_T = conditional_t<
             RQ == ref_quals::none, add_lvalue_reference_t<cv_T>,
             conditional_t<
                 RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_T>, add_lvalue_reference_t<cv_T>
             >
         >;
         return compat::invoke_r<R>( static_cast<cv_ref_T>( *static_cast<cv_T*>( s.pobj_ ) ), std::forward<Args>( args )... );
     }
 };
 
 template<ref_quals RQ, bool Const, bool NoEx, class F, class R, class ...Args>
 struct mo_invoke_local_holder
 {
     static R invoke_local( storage s, Args&&... args ) noexcept( NoEx )
     {
         using T = remove_reference_t<F>;
         using cv_T = conditional_t<Const, add_const_t<T>, T>;
         using cv_ref_T = conditional_t<
             RQ == ref_quals::none, add_lvalue_reference_t<cv_T>,
             conditional_t<
                 RQ == ref_quals::rvalue, add_rvalue_reference_t<cv_T>, add_lvalue_reference_t<cv_T>
             >
         >;
 
         return compat::invoke_r<R>( static_cast<cv_ref_T>( *static_cast<cv_T*>( s.addr() ) ), std::forward<Args>( args )... );
     }
 };
 
 enum class op_type { move, destroy };
 
 template <ref_quals RQ, bool Const, bool NoEx, class R, class ...Args>
 struct move_only_function_base
 {
     move_only_function_base() = default;
 
     move_only_function_base( move_only_function_base&& rhs ) noexcept
     {
         manager_ = rhs.manager_;
         manager_( op_type::move, s_, &rhs.s_ );
 
         invoke_ = rhs.invoke_;
         rhs.invoke_ = nullptr;
         rhs.manager_ = &manage_empty;
     }
 
     ~move_only_function_base()
     {
         destroy();
     }
 
     void swap( move_only_function_base& rhs ) noexcept
     {
         // to properly swap with storages, we need to treat the destination storage
         // the same as the source storage, which means that we need to use the
         // source manager_'s move operation
 
         storage s;
         rhs.manager_( op_type::move, s, &rhs.s_ );
         manager_( op_type::move, rhs.s_, &s_ );
         rhs.manager_( op_type::move, s_, &s );
 
         std::swap( manager_, rhs.manager_ );
         std::swap( invoke_, rhs.invoke_ );
     }
 
     move_only_function_base& operator=( move_only_function_base&& rhs )
     {
         destroy();
 
         manager_ = rhs.manager_;
         manager_( op_type::move, s_, &rhs.s_ );
         invoke_ = rhs.invoke_;
 
         rhs.invoke_ = nullptr;
         rhs.manager_ = &manage_empty;
         return *this;
     }
 
     move_only_function_base& operator=( std::nullptr_t ) noexcept
     {
         destroy();
         invoke_ = nullptr;
         manager_ = &manage_empty;
         return *this;
     }
 
     static void manage_empty( op_type, detail::storage&, detail::storage* )
     {
     }
 
     static void manage_function( op_type op, detail::storage& s, detail::storage* src )
     {
         switch( op )
         {
             case op_type::move:
                 s.pfn_ = src->pfn_;
                 src->pfn_ = nullptr;
                 break;
 
             default:
                 break;
         }
 
     }
 
     template<class VT>
     static void manage_object( op_type op, detail::storage& s, detail::storage* src )
     {
         switch( op )
         {
             case op_type::destroy:
                 delete static_cast<VT*>( s.pobj_ );
                 break;
 
             case op_type::move:
                 s.pobj_ = src->pobj_;
                 src->pobj_ = nullptr;
                 break;
 
             default:
                 break;
         }
     }
 
     template<class VT>
     static void manage_local( op_type op, detail::storage& s, detail::storage* src )
     {
         switch( op )
         {
             case op_type::destroy:
                 static_cast<VT*>( s.addr() )->~VT();
                 break;
 
             case op_type::move:
             {
                 VT* p = static_cast<VT*>( src->addr() );
                 new(s.addr()) VT( std::move( *p ) );
                 // destruct the element here because move construction will leave the container empty
                 // outside of this function
                 p->~VT();
                 break;
             }
 
             default:
                 break;
         }
     }
 
     template <ref_quals RQ2, bool Const2, bool NoEx2, class R2, class ...Args2>
     void
     move_from_compatible_base( move_only_function_base<RQ2, Const2, NoEx2, R2, Args2...>& base )
     {
         using polymorphic_base = move_only_function_base<RQ2, Const2, NoEx2, R2, Args2...>;
 
         manager_ = base.manager_;
 
         manager_( op_type::move, s_, &base.s_ );
         invoke_ = base.invoke_;
 
         base.invoke_ = nullptr;
         base.manager_ = &polymorphic_base::manage_empty;
     }
 
     template<class F>
     void base_init( std::true_type, F&& f )
     {
         move_from_compatible_base( f );
     }
 
     template<class ...F>
     void base_init( std::false_type, F&&... )
     {
     }
 
     template<class VT, class ...CArgs>
     void init( std::false_type /* is_function */, CArgs&& ...args )
     {
         if( is_polymorphic_function<VT>::value )
         {
             base_init( is_polymorphic_function<VT>{}, std::forward<CArgs>( args )... );
             return;
         }
 
         if( !storage::use_sbo<VT>() )
         {
             s_.pobj_ = new VT( std::forward<CArgs>( args )... );
             invoke_ = &mo_invoke_object_holder<RQ, Const, NoEx, VT, R, Args...>::invoke_object;
             manager_ = &manage_object<VT>;
         }
         else
         {
             new( s_.addr() ) VT( std::forward<CArgs>( args )... );
             invoke_ = &mo_invoke_local_holder<RQ, Const, NoEx, VT, R, Args...>::invoke_local;
             manager_ = &manage_local<VT>;
         }
     }
 
     template<class VT, class ...CArgs>
     void init( std::true_type /* is_function */, CArgs ...args )
     {
         R (*pfn)( Args... ) = get_first_arg( args... );
         s_.pfn_ = reinterpret_cast<void(*)()>( pfn );
         invoke_ = &detail::mo_invoke_function_holder<NoEx, R, Args...>::invoke_function;
         manager_ = &manage_function;
     }
 
     template <class VT, class ...CArgs>
     void init( type_identity<VT>, CArgs&& ...args )
     {
         init<VT>( std::is_function<remove_pointer_t<VT>>(), std::forward<CArgs>( args )... );
     }
 
     void destroy()
     {
         manager_( op_type::destroy, s_, nullptr );
     }
 
     explicit operator bool() const noexcept
     {
         return invoke_ != nullptr;
     }
 
     detail::storage s_;
 #if defined(__cpp_noexcept_function_type)
     R ( *invoke_ )( detail::storage, Args&&... ) noexcept( NoEx ) = nullptr;
 #else
     R ( *invoke_ )( detail::storage, Args&&... ) = nullptr;
 #endif
     void ( *manager_ )( op_type, detail::storage&, detail::storage* ) = &manage_empty;
 };
 
 } // namespace detail
 
 template<class R, class ...Args>
 class move_only_function<R( Args... )> : detail::move_only_function_base<detail::ref_quals::none, false, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::none, false, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args )
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) &> : detail::move_only_function_base<detail::ref_quals::lvalue, false, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::lvalue, false, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) &
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) &&> : detail::move_only_function_base<detail::ref_quals::rvalue, false, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::rvalue, false, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) &&
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const> : detail::move_only_function_base<detail::ref_quals::none, true, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::none, true, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const&> : detail::move_only_function_base<detail::ref_quals::lvalue, true, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::lvalue, true, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const &
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const&&> : detail::move_only_function_base<detail::ref_quals::rvalue, true, false, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::rvalue, true, false, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, false, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, false, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const &&
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 #if defined(__cpp_noexcept_function_type)
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) noexcept> : detail::move_only_function_base<detail::ref_quals::none, false, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::none, false, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) & noexcept> : detail::move_only_function_base<detail::ref_quals::lvalue, false, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::lvalue, false, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) & noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) && noexcept> : detail::move_only_function_base<detail::ref_quals::rvalue, false, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::rvalue, false, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, false, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) && noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const noexcept> : detail::move_only_function_base<detail::ref_quals::none, true, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::none, true, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::none, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const& noexcept> : detail::move_only_function_base<detail::ref_quals::lvalue, true, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::lvalue, true, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::lvalue, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const& noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 template<class R, class ...Args>
 class move_only_function<R( Args... ) const&& noexcept> : detail::move_only_function_base<detail::ref_quals::rvalue, true, true, R, Args...>
 {
 private:
 
     template<detail::ref_quals, bool, bool, class, class ...>
     friend struct detail::move_only_function_base;
 
     using base = detail::move_only_function_base<detail::ref_quals::rvalue, true, true, R, Args...>;
 
 public:
 
     move_only_function() noexcept
     {
     }
 
     move_only_function( std::nullptr_t ) noexcept
         : move_only_function()
     {
     }
 
     template<
         class F,
         class VT = decay_t<F>,
         enable_if_t<
             !std::is_same<move_only_function, remove_cvref_t<F>>::value &&
             !detail::is_in_place_type_t<VT>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, true, VT, R, Args...>::value,
             int> = 0
     >
     move_only_function( F&& f ) noexcept( detail::nothrow_init<VT, F>::value )
     {
         if( detail::is_nullary_arg( std::forward<F>( f ) ) ) return;
         base::init( type_identity<VT>{}, std::forward<F>( f ) );
     }
 
     template<
         class T, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, CArgs&& ... args ) noexcept( detail::nothrow_init<T, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, std::forward<CArgs>( args )... );
     }
 
     template<
         class T, class U, class ...CArgs,
         enable_if_t<
             std::is_constructible<T, std::initializer_list<U>&, CArgs...>::value &&
             detail::is_callable_from<detail::ref_quals::rvalue, true, true, T, R, Args...>::value,
             int> = 0
     >
     explicit move_only_function( in_place_type_t<T>, std::initializer_list<U> il, CArgs&& ... args ) noexcept( detail::nothrow_init<T, std::initializer_list<U>&, CArgs...>::value )
     {
         static_assert( std::is_same<T, decay_t<T>>::value, "T and `decay_t<T>` must be the same" );
         base::init( type_identity<T>{}, il, std::forward<CArgs>( args )... );
     }
 
     move_only_function( move_only_function const& ) = delete;
     move_only_function( move_only_function&& ) = default;
 
     ~move_only_function() = default;
 
     move_only_function& operator=( move_only_function&& rhs )
     {
         if( this != &rhs )
         {
             this->base::operator=( static_cast<base&&>( rhs ) );
         }
         return *this;
     }
 
     move_only_function& operator=( std::nullptr_t ) noexcept
     {
         this->base::operator=( nullptr );
         return *this;
     }
 
     template<class F> move_only_function& operator=( F&& f )
     {
         move_only_function( std::forward<F>( f ) ).swap( *this );
         return *this;
     }
 
     friend bool operator==( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return fn.invoke_ == nullptr;
     }
 
     friend bool operator!=( move_only_function const& fn, std::nullptr_t ) noexcept
     {
         return !( fn == nullptr );
     }
 
     void swap( move_only_function& rhs ) noexcept
     {
         if( this != &rhs )
         {
             this->base::swap( rhs );
         }
     }
 
     friend void swap( move_only_function& lhs, move_only_function& rhs ) noexcept
     {
         lhs.swap( rhs );
     }
 
     explicit operator bool() const noexcept
     {
         return static_cast<bool>( *static_cast<base const*>( this ) );
     }
 
     R operator()( Args... args ) const&& noexcept
     {
         return this->invoke_( this->s_, std::forward<Args>( args )... );
     }
 };
 
 #endif
 
 } // namespace compat
 } // namespace boost
 
 #if BOOST_WORKAROUND(BOOST_GCC, >= 6 * 10000)
 #   pragma GCC diagnostic pop
 #endif
 
 #endif // #ifndef BOOST_COMPAT_MOVE_ONLY_FUNCTION_HPP_INCLUDED

This page was automatically generated by the 2.3.7 LXR engine. The LXR team