/Users/dlarimer/dev/libs/cmt/include/boost/cmt/future.hpp

#ifndef _BOOST_CMT_FUTURE_HPP
#define _BOOST_CMT_FUTURE_HPP
#include <boost/cmt/retainable.hpp>
#include <boost/cmt/error.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/cmt/mutex.hpp>
#include <boost/optional.hpp>
#include <boost/chrono.hpp>

namespace boost { namespace cmt {
    using boost::chrono::microseconds;

    class abstract_thread;
    class promise_base :  public retainable {
         public:
             typedef retainable_ptr<promise_base> ptr;
             promise_base():m_blocked_thread(0),m_timeout(microseconds::max()){}
             virtual ~promise_base(){}

             virtual bool ready()const = 0;
         protected:
             void enqueue_thread();
             void wait( const microseconds& timeout_us );
             void notify();
             virtual void set_timeout()=0;
             virtual void set_exception( const boost::exception_ptr& e )=0;

         private:
             friend class thread;
             friend class thread_private;

             abstract_thread*          m_blocked_thread;
             microseconds              m_timeout;    
    };

    struct void_t {};

    template<typename T = void_t>
    class promise : public promise_base {
        public:
            typedef retainable_ptr<promise> ptr;

            promise(){}
            promise( const T& v ):m_value(v){}

            bool ready()const { 
                boost::unique_lock<mutex> lock( m_mutex );
                return !!m_value || m_error; 
            }
            bool error()const { return m_error; }
            operator const T&()const  { return wait();  }

            const T& wait(const microseconds& timeout = microseconds::max() ) {
                { // lock while we check values
                    boost::unique_lock<mutex> lock( m_mutex );
                    if( m_error ) boost::rethrow_exception(m_error);
                    if( m_value ) return *m_value;
                    enqueue_thread();
                } // unlock before yielding, but after enqueing
                promise_base::wait(timeout);
                if( m_error ) boost::rethrow_exception(m_error);
                if( m_value ) return *m_value;
                BOOST_THROW_EXCEPTION( error::future_value_not_ready() ); 
                return *m_value;
            }
            void set_exception( const boost::exception_ptr& e ) {
                {
                    boost::unique_lock<mutex> lock( m_mutex );
                    m_error = e;
                }
                notify();
            }
            void set_value( const T& v ) {
                {
                    boost::unique_lock<mutex> lock( m_mutex );
                    if( m_error ) 
                        return;
                    m_value = v;
                }
                notify();
            }
            
        private:
            void set_timeout() {
                {
                    boost::unique_lock<mutex> lock( m_mutex );
                    if( m_value ) 
                        return;
                    m_error = boost::copy_exception( error::future_wait_timeout() );
                }
                notify();
            }

            mutable mutex           m_mutex;
            boost::exception_ptr    m_error;
            boost::optional<T>      m_value;
    };

    template<>
    class promise<void> : public promise<void_t> {};

    template<typename T = void_t>
    class future {
        public:
                typedef typename promise<T>::ptr promise_ptr;
            typedef T                        value_type;

            future( const promise_ptr& p = promise_ptr() )
            :m_prom(p){}
            future( const T& v ):m_prom( new promise<T>(v) ){}

            bool valid()const { return !!m_prom;       }
            bool ready()const { return m_prom->ready();}
            bool error()const { return valid() ? m_prom->error() : false; }
            operator const T&()const { 
                if( !m_prom ) BOOST_THROW_EXCEPTION( error::null_future() );
                return m_prom->wait();
            }
            const T& wait(const microseconds& timeout = microseconds::max() ) { 
                if( !m_prom ) BOOST_THROW_EXCEPTION( error::null_future() );
                return m_prom->wait(timeout); 
            }

        private:
            promise_ptr m_prom;
    };

    template<>
    class future<void> : public future<void_t> {
        public:
            future( const  promise<void_t>::ptr& p =  promise<void_t>::ptr() )
            :future<void_t>(p){}
            future( const void_t& v ):future<void_t>(v){}
    };


} }


#endif