Revised on 4 Mar 2004

Futures.hpp

/*
 * Copyright (C) 2004
 * Slawomir Lisznianski <slisznianski@asyncnet.com>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation. Slawomir Lisznianski makes no
 * representations about the suitability of this software for any
 * purpose. It is provided "as is" without express or implied warranty.
 *
 */

#ifndef RHA_FUTURES_HPP
#define RHA_FUTURES_HPP

#include <stdexcept>

#include <boost/thread/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/variant/variant.hpp>
#include <boost/variant/static_visitor.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/get.hpp>
#include <boost/mpl/front.hpp>
#include <boost/mpl/pop_front.hpp>
#include <boost/mpl/empty.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/push_back.hpp>
#include <boost/optional.hpp>
#include <boost/call_traits.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>

namespace Rha
{
  class UnboundFuture :
    public std::runtime_error
  {
  public:
    UnboundFuture() :
      std::runtime_error("call to unbound future")
    { }
  };

  namespace Details
  {
    /*
    * Unusable is a helper to handle objects returning void.
    */
    struct Unusable
    {
      Unusable() {}
      template<typename T> Unusable(const T&) {}
    };

    /*
    * ReturnTypeHelper used to deal with void return
    * type.
    */
    template<typename ResultType>
    struct ReturnTypeHelper
    {
      typedef ResultType Type;
    };

    template<>
    struct ReturnTypeHelper<void>
    {
      typedef Unusable Type;
    };
  }

  template<typename E0 = boost::detail::variant::void_,
           typename E1 = boost::detail::variant::void_,
           typename E2 = boost::detail::variant::void_,
           typename E3 = boost::detail::variant::void_,
           typename E4 = boost::detail::variant::void_,
           typename E5 = boost::detail::variant::void_,
           typename E6 = boost::detail::variant::void_,
           typename E7 = boost::detail::variant::void_,
           typename E8 = boost::detail::variant::void_>
  struct FutureRegistry
  {
    typedef E0 Exception0;
    typedef E1 Exception1;
    typedef E2 Exception2;
    typedef E3 Exception3;
    typedef E4 Exception4;
    typedef E5 Exception5;
    typedef E6 Exception6;
    typedef E7 Exception7;
    typedef E8 Exception8;
    template<typename R> class Future;
  private:
    template<typename ReturnType>
    struct ReturnTypeList
    {
      typedef boost::variant<ReturnType,
                             Exception0,
                             Exception1,
                             Exception2,
                             Exception3,
                             Exception4,
                             Exception5,
                             Exception6,
                             Exception7,
                             Exception8> Type;
    };

    template<typename R>
    struct TaskContext
    {
      typedef R ReturnType;

      TaskContext(const boost::function0<ReturnType>& functor) :
        MReleased(false),
        M_functor(functor)
      { }

      bool                                          MReleased;
      boost::function0<ReturnType>                  M_functor;
      typename ReturnTypeList<typename Details::ReturnTypeHelper<ReturnType>::Type>::Type MResult;
      boost::condition                              M_condition;
      boost::mutex                                  M_mutex;
    };

    template <bool isEmpty, class ExceptionTypeList, bool isVoid>
    struct CallerImpl
    {
      template<class _Fun, class ResList>
      static void call(_Fun f, ResList* res)
      {
        f();
        *res = Details::Unusable();
      }
    };

    template <class ExceptionTypeList>
    struct CallerImpl<true, ExceptionTypeList, false>
    {
      template<class _Fun, class ResList>
      static void call(_Fun f, ResList* res)
      {
        *res = f();
      }
    };

    template <class ExceptionTypeList, bool isVoid>
    struct CallerImpl<false, ExceptionTypeList, isVoid>
    {
      template<class _Fun, class ResList>
      static void call(_Fun f, ResList* res)
      {
        try
        {
          typedef typename boost::mpl::pop_front<ExceptionTypeList>::type popped;
          CallerImpl<boost::mpl::empty<popped>::value, popped, isVoid>::call(f, res);
        }
        catch (typename boost::mpl::front<ExceptionTypeList>::type e)
        {
          *res = e;
        }
      }
    };

    template<typename R>
    class JoinableTask
    {
    public:
      typedef R ReturnType;
      class Proxy;
      friend class Future<ReturnType>;

      JoinableTask(const boost::function0<ReturnType>& functor) :
        M_taskContext(new TaskContext<ReturnType> (functor))
      { }

      Proxy proxy()
      {
        return Proxy(M_taskContext);
      }

    private:
      class Proxy
      {
      public:
        Proxy(typename boost::call_traits<boost::shared_ptr<TaskContext<ReturnType> > >::param_type taskContext) :
          M_sentry(new _Sentry_(taskContext))
        { }

        ~Proxy()
        {  }

        void operator()()
        {
          try
          {
            // Remove the return value type. The rest in the list are exception types.
            //
            typedef typename boost::mpl::pop_front<typename ReturnTypeList<typename Details::ReturnTypeHelper<ReturnType>::Type>::Type::types>::type popped;
            CallerImpl<boost::mpl::empty<popped>::value, popped, ::boost::is_void<ReturnType>::value>::call(M_sentry->M_taskContext->M_functor, &M_sentry->M_taskContext->MResult);
          }
          catch (...)
          {
            // A task has thrown an exception that is not listed in the
            // exception-specification of this FutureRegistry.
            //
            std::unexpected();
          }
        }

      private:
        struct _Sentry_
        {
          _Sentry_(typename boost::call_traits<boost::shared_ptr<TaskContext<ReturnType> > >::param_type taskContext) :
            M_taskContext(taskContext)
          { }

          ~_Sentry_()
          {
            boost::mutex::scoped_lock lock__(M_taskContext->M_mutex);
            M_taskContext->MReleased = true;
            M_taskContext->M_condition.notify_all();
          }
          boost::shared_ptr<TaskContext<ReturnType> > M_taskContext;
        };
        boost::shared_ptr<_Sentry_> M_sentry;
      };
      boost::shared_ptr<TaskContext<ReturnType> > M_taskContext;
    };
  public:
    template<typename R>
    class Future
    {
    public:
      typedef R ReturnType;
      typedef R result_type; // Boost compatibility

      Future(Future const& future) :
        M_taskContext(future.M_taskContext)
      {  }

      template<class _Scheduler, class _Function>
        Future(_Scheduler& s, _Function f)
      {
        JoinableTask<ReturnType> jt(f);
        s.push(jt.proxy());
        M_taskContext = jt.M_taskContext;
      }

      Future()
      { }

      Future& operator=(Future const& r)
      {
        M_taskContext = r.M_taskContext;
        return (*this);
      }

      typename Details::ReturnTypeHelper<ReturnType>::Type join()
      {
        if (!this->bound())
          throw UnboundFuture();
        // Check if the proxy has released us.
        //
        if (!M_taskContext->MReleased)
        {
          boost::mutex::scoped_lock lock__(M_taskContext->M_mutex);
          while(!M_taskContext->MReleased)
            M_taskContext->M_condition.wait(lock__);
        } // Lock scope ends.
        if (typename Details::ReturnTypeHelper<ReturnType>::Type const* p =
              boost::get<typename Details::ReturnTypeHelper<ReturnType>::Type>(&M_taskContext->MResult))
        {
          return *p;
        }
        boost::apply_visitor(Rethrower(), M_taskContext->MResult);
        // We should never reach past this line.
        //
        std::unexpected();
      }

      typename Details::ReturnTypeHelper<ReturnType>::Type operator*()
      {
        return join();
      }

      bool bound()
      {
        return (M_taskContext);
      }
    private:
      struct Rethrower : boost::static_visitor<>
      {
        template<class Exception>
          void operator()(Exception& e) const
        {
          throw e;
        }
      };

      boost::shared_ptr<TaskContext<ReturnType> > M_taskContext;
    };
  };
}

#endif // RHA_FUTURES_HPP

---

© Copyright Slawomir Lisznianski 2003-2004. All Rights Reserved.

Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Slawomir Lisznianski makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.