Re: [boost] Review Request: future library (Gaskill version)

From: vicente.botet (vicente.botet_at_[hidden])
Date: 2008-04-14 07:21:44

Hi Olivier,

This is very elegant on the context of the future library.

I was thinking on some kind of mpl generation for the exception_ptr library 
but I didn't thounk to wrappe the call.

----- Original Message ----- 
From: "Kowalke Oliver (QD IT PA AS)" <Oliver.Kowalke_at_[hidden]>
To: <boost_at_[hidden]>
Sent: Monday, April 14, 2008 9:26 AM
Subject: Re: [boost] Review Request: future library (Gaskill version)

> Sorry - didn't read your docu carefully. As you say in the docs 'However, 
> arbitrary user-defined exception types cannot be supported.'.
>
> What about to specify an mpl::vector with arbitrary user-defined exception 
> types?
> I'm using your future library siunce last year with this little 
> modification (at least for me it works).
> Oliver
>

> template<
>     typename R,
>     typename V = mpl::vector<>
>  >
>  class future_wrapper
>  {
>    public:
>      future_wrapper(const boost::function<R (void)> &fn, const promise<R> 
> &ft ) : fn_(fn), ft_(ft) {}; // stores fn and ft
>      void operator()() throw() { // executes fn() and places the outcome 
> into ft
>
>            typedef typename boost::mpl::fold<
>                V,
>                detail::exec_function,
>                detail::catch_exception< boost::mpl::_1, boost::mpl::_2 >
>            >::type             exec_type;
>
>           detail::catch_ellipsis< exec_type >::exec( fn_, ft_);
>      }
>    private:
>      boost::function<R (void)> fn_;
>      promise<R> ft_;
>  };
>
>
> struct exec_function
>        {
>                template< typename R >
>                static void exec(
>                        boost::function< R ( void) > const& fn,
>                        boost::promise< R > & ft)
>                { ft.set( fn() ); }
>
>                static void exec(
>                        boost::function< void ( void) > const& fn,
>                        boost::promise< void > & ft)
>                {
>                        fn();
>                        ft.set();
>                }
>        };
>
>        template<
>                typename P,
>                typename E
>        >
>        struct catch_exception
>        {
>                template< typename R >
>                static void exec(
>                        boost::function< R ( void) > const& fn,
>                        boost::promise< R > & ft)
>                {
>                        try
>                        { P::exec( fn, ft); }
>                        catch ( E const& e)
>                        { ft.set_exception( e); }
>                }
>
>                static void exec(
>                        boost::function< void ( void) > const& fn,
>                        boost::promise< void > & ft)
>                {
>                        try
>                        { P::exec( fn, ft); }
>                        catch ( E const& e)
>                        { ft.set_exception( e); }
>                }
>        };
>
>        template< typename P >
>        struct catch_ellipsis
>        {
>                template< typename R >
>                static void exec(
>                        boost::function< R ( void) > const& fn,
>                        boost::promise< R > & ft)
>                {
>                        try
>                        { P::exec( fn, ft); }
>                        catch (...)
>            { ft.set_exception(boost::detail::current_exception() ); }
>                }
>
>                static void exec(
>                        boost::function< void ( void) > const& fn,
>                        boost::promise< void > & ft)
>                {
>                        try
>                        { P::exec( fn, ft); }
>                        catch (...)
>            { ft.set_exception(boost::detail::current_exception() ); }
>                }
>        };
>
>> Hello,
>> is it correct that user defined exceptions thrown by the
>> defered function object will be rethrown as as
>> std::runtime_error (if it was derived from std::exception) or
>> std::bad_exception?
>> If yes - what about specifying an mpl::vector with user
>> defined exception types (passing to future_wrapper etc.)?
>> regards, oliver

I see only a problem: the interface of the future_wrapper is changed.

Maybe something like
    template<
        typename R,
        typename V = BOOST_EXCEPTION_PTR_USER_EXCEPTION_VECTOR
    class future_wrapper ...

allow to preserv the interface.

Another problem is that we need to do the same for each class using the 
exception_ptr library.

It will be nice if the exec_function, the catch_exception and the 
catch_ellipsis do not depend directly on the promise<R>. I don't know if it 
is possible to make a wrap_call template with a template parameter Promise 
and having these three classes nested.

template <class template<class> PromiseTmpl>
struct wrap_call {
    struct exec_function
    {
        template< typename R, class Policy= promise_policy< PromiseTmpl< R > 
 > >
        static void exec(
            boost::function< R ( void) > const& fn,
            PromiseTmpl< R > & ft)
                { Policy::set(ft,  fn() ); }
        // ...

    template <
        typename V = BOOST_EXCEPTION_PTR_USER_EXCEPTION_VECTOR
    >
    struct call {
        typedef typename boost::mpl::fold<
                    V,
                    wrap_call<PromiseTmpl>::exec_function,
                    wrap_call<PromiseTmpl>::catch_exception< boost::mpl::_1, 
boost::mpl::_2 >
                >::type             exec_type;

        typedef wrap_call<PromiseTmpl>::catch_ellipsis< exec_type > type;
    };
}

A policy class should be needed to take care of the promise concept 
interface

template <class Promise>
struct promise_policy  {
    void set(Promise& p, const R &v) {p.set(v);}
    void set_exception(Promise& p, const exception_ptr&e) 
{p.set_exception(e);}
};

And use it as follows
    template<
        typename R,
        typename V = BOOST_EXCEPTION_PTR_USER_EXCEPTION_VECTOR
    class future_wrapper {
         // ...
         future_wrapper(const boost::function<R (void)> &fn, const 
promise<R> &ft ) : fn_(fn), ft_(ft) {}; // stores fn and ft
         void operator()() throw() { // executes fn() and places the outcome 
into ft

               exception_ptr::wrap_call<promise>::call<V>::exec( fn_, ft_);

        }
         // ...

Do you think that this could work?

Best
_____________________
Vicente Juan Botet Escriba