|  | Home | Libraries | People | FAQ | More | 
          A packaged_task<> wraps a callable target that
          returns a value so that the return value can be computed asynchronously.
        
          Conventional usage of packaged_task<> is like this:
        
packaged_task<> with template arguments matching
              the signature of the callable. Pass the callable to the constructor.
            packaged_task::get_future() and capture
              the returned future<> instance.
            fiber to run the new packaged_task<>, passing any arguments required
              by the original callable.
            fiber::detach() on the newly-launched fiber.
            future<>.
            
          This is, in fact, pretty much what fibers::async()
encapsulates.
        
#include <boost/fiber/future/packaged_task.hpp> namespace boost { namespace fibers { template< class R, typename ... Args > class packaged_task< R( Args ... ) > { public: packaged_task() noexcept; template< typename Fn > explicit packaged_task( Fn &&); template< typename Fn, typenameAllocator> packaged_task(std::allocator_arg_t, Allocator const&, Fn &&); packaged_task( packaged_task &&) noexcept; packaged_task & operator=( packaged_task &&) noexcept; packaged_task( packaged_task const&) = delete; packaged_task & operator=( packaged_task const&) = delete; ~packaged_task(); void swap( packaged_task &) noexcept; bool valid() const noexcept; future< R > get_future(); void operator()( Args ...); void reset(); }; template< typename Signature > void swap( packaged_task< Signature > &, packaged_task< Signature > &) noexcept; }}
packaged_task()
        packaged_task() noexcept;
                Constructs an object of class packaged_task
                with no shared state.
              
Nothing.
packaged_task()
        template< typename Fn > explicit packaged_task( Fn && fn); template< typename Fn, typenameAllocator> packaged_task(std::allocator_arg_t, Allocator const& alloc, Fn && fn);
                Constructs an object of class packaged_task
                with a shared state and copies
                or moves the callable target fn
                to internal storage.
              
Exceptions caused by memory allocation.
                The signature of Fn
                should have a return type convertible to R.
              
packaged_task( packaged_task && other) noexcept;
                Creates a packaged_task by moving the shared
                state from other.
              
                other contains no
                valid shared state.
              
Nothing.
~packaged_task();
                Destroys *this
                and abandons the shared state
                if shared state is ready; otherwise stores future_error
                with error condition future_errc::broken_promise
                as if by promise::set_exception(): the shared
                state is set ready.
              
operator=()
packaged_task & operator=( packaged_task && other) noexcept;
                Transfers the ownership of shared state
                to *this.
              
                other contains no
                valid shared state.
              
Nothing.
swap()
void swap( packaged_task & other) noexcept;
                Swaps the shared state between
                other and *this.
              
Nothing.
valid()
bool valid() const noexcept;
                Returns true if *this
                contains a shared state.
              
Nothing.
get_future()
future< R > get_future();
                A future<> with the same shared
                state.
              
                future_error with
                future_errc::future_already_retrieved or future_errc::no_state.
              
operator()()
void operator()( Args && ... args);
                Invokes the stored callable target. Any exception thrown by the callable
                target fn is stored
                in the shared state as if by
                promise::set_exception(). Otherwise, the value
                returned by fn is
                stored in the shared state as if by promise::set_value().
              
                future_error with
                future_errc::no_state.
              
reset()
void reset();
Resets the shared state and abandons the result of previous executions. A new shared state is constructed.
                future_error with
                future_errc::no_state.
              
swap()
template< typename Signature > void swap( packaged_task< Signature > & l, packaged_task< Signature > & r) noexcept;
                Same as l.swap(
                r).