#ifndef BOOST_THREAD_THREAD_COMMON_HPP

#define BOOST_THREAD_THREAD_COMMON_HPP

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

// (C) Copyright 2007-8 Anthony Williams

#include <boost/thread/exceptions.hpp>

#include <ostream>

#include <boost/thread/detail/move.hpp>

#include <boost/thread/mutex.hpp>

#include <boost/thread/xtime.hpp>

#include <boost/thread/detail/thread_heap_alloc.hpp>

#include <boost/utility.hpp>

#include <boost/assert.hpp>

#include <list>

#include <algorithm>

#include <boost/ref.hpp>

#include <boost/cstdint.hpp>

#include <boost/bind.hpp>

#include <stdlib.h>

#include <memory>

#include <boost/utility/enable_if.hpp>

#include <boost/type_traits/remove_reference.hpp>

#include <boost/config/abi_prefix.hpp>

#ifdef BOOST_MSVC

#pragma warning(push)

#pragma warning(disable:4251)

#endif

namespace boost

{

    namespace detail

    {

        template<typename F>

        class thread_data:

            public detail::thread_data_base

        {

        public:

#ifdef BOOST_HAS_RVALUE_REFS

            thread_data(F&& f_):

                f(static_cast<F&&>(f_))

            {}

#else

            thread_data(F f_):

                f(f_)

            {}

            thread_data(detail::thread_move_t<F> f_):

                f(f_)

            {}

#endif            

            void run()

            {

                f();

            }

        private:

            F f;

            void operator=(thread_data&);

            thread_data(thread_data&);

        };

        template<typename F>

        class thread_data<boost::reference_wrapper<F> >:

            public detail::thread_data_base

        {

        private:

            F& f;

            void operator=(thread_data&);

            thread_data(thread_data&);

        public:

            thread_data(boost::reference_wrapper<F> f_):

                f(f_)

            {}

            void run()

            {

                f();

            }

        };

        template<typename F>

        class thread_data<const boost::reference_wrapper<F> >:

            public detail::thread_data_base

        {

        private:

            F& f;

            void operator=(thread_data&);

            thread_data(thread_data&);

        public:

            thread_data(const boost::reference_wrapper<F> f_):

                f(f_)

            {}

            void run()

            {

                f();

            }

        };

    }

    class BOOST_THREAD_DECL thread

    {

    private:

        thread(thread&);

        thread& operator=(thread&);

        void release_handle();

        mutable boost::mutex thread_info_mutex;

        detail::thread_data_ptr thread_info;

        void start_thread();

        explicit thread(detail::thread_data_ptr data);

        detail::thread_data_ptr get_thread_info() const;

#ifdef BOOST_HAS_RVALUE_REFS

        template<typename F>

        static inline detail::thread_data_ptr make_thread_info(F&& f)

        {

            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(static_cast<F&&>(f)));

        }

        static inline detail::thread_data_ptr make_thread_info(void (*f)())

        {

            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(f));

        }

#else

        template<typename F>

        static inline detail::thread_data_ptr make_thread_info(F f)

        {

            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));

        }

        template<typename F>

        static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t<F> f)

        {

            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));

        }

        struct dummy;

#endif

    public:

        thread();

        ~thread();

#ifdef BOOST_HAS_RVALUE_REFS

        template <class F>

        thread(F&& f):

            thread_info(make_thread_info(static_cast<F&&>(f)))

        {

            start_thread();

        }

        thread(thread&& other)

        {

            thread_info.swap(other.thread_info);

        }

        thread& operator=(thread&& other)

        {

            thread_info=other.thread_info;

            other.thread_info.reset();

            return *this;

        }

        thread&& move()

        {

            return static_cast<thread&&>(*this);

        }

#else

#ifdef BOOST_NO_SFINAE

        template <class F>

        explicit thread(F f):

            thread_info(make_thread_info(f))

        {

            start_thread();

        }

#else

        template <class F>

        explicit thread(F f,typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >, dummy* >::type=0):

            thread_info(make_thread_info(f))

        {

            start_thread();

        }

#endif

        template <class F>

        explicit thread(detail::thread_move_t<F> f):

            thread_info(make_thread_info(f))

        {

            start_thread();

        }

        thread(detail::thread_move_t<thread> x)

        {

            thread_info=x->thread_info;

            x->thread_info.reset();

        }

        thread& operator=(detail::thread_move_t<thread> x)

        {

            thread new_thread(x);

            swap(new_thread);

            return *this;

        }

        operator detail::thread_move_t<thread>()

        {

            return move();

        }

        detail::thread_move_t<thread> move()

        {

            detail::thread_move_t<thread> x(*this);

            return x;

        }

#endif

        template <class F,class A1>

        thread(F f,A1 a1):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))

        {

            start_thread();

        }

        template <class F,class A1,class A2>

        thread(F f,A1 a1,A2 a2):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3>

        thread(F f,A1 a1,A2 a2,A3 a3):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4,class A5>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))

        {

            start_thread();

        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>

        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):

            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))

        {

            start_thread();

        }

        void swap(thread& x)

        {

            thread_info.swap(x.thread_info);

        }

        class id;

        id get_id() const;

        bool joinable() const;

        void join();

        bool timed_join(const system_time& wait_until);

        template<typename TimeDuration>

        inline bool timed_join(TimeDuration const& rel_time)

        {

            return timed_join(get_system_time()+rel_time);

        }

        void detach();

        static unsigned hardware_concurrency();

        typedef detail::thread_data_base::native_handle_type native_handle_type;

        native_handle_type native_handle();

        // backwards compatibility

        bool operator==(const thread& other) const;

        bool operator!=(const thread& other) const;

        static inline void yield()

        {

            this_thread::yield();

        }

        static inline void sleep(const system_time& xt)

        {

            this_thread::sleep(xt);

        }

        // extensions

        void interrupt();

        bool interruption_requested() const;

    };

    inline void swap(thread& lhs,thread& rhs)

    {

        return lhs.swap(rhs);

    }

#ifdef BOOST_HAS_RVALUE_REFS

    inline thread&& move(thread&& t)

    {

        return t;

    }

#else

    inline thread move(detail::thread_move_t<thread> t)

    {

        return thread(t);

    }

#endif

    namespace this_thread

    {

        class BOOST_THREAD_DECL disable_interruption

        {

            disable_interruption(const disable_interruption&);

            disable_interruption& operator=(const disable_interruption&);

            bool interruption_was_enabled;

            friend class restore_interruption;

        public:

            disable_interruption();

            ~disable_interruption();

        };

        class BOOST_THREAD_DECL restore_interruption

        {

            restore_interruption(const restore_interruption&);

            restore_interruption& operator=(const restore_interruption&);

        public:

            explicit restore_interruption(disable_interruption& d);

            ~restore_interruption();

        };

        thread::id BOOST_THREAD_DECL get_id();

        void BOOST_THREAD_DECL interruption_point();

        bool BOOST_THREAD_DECL interruption_enabled();

        bool BOOST_THREAD_DECL interruption_requested();

        inline void sleep(xtime const& abs_time)

        {

            sleep(system_time(abs_time));

        }

    }

    class thread::id

    {

    private:

        detail::thread_data_ptr thread_data;

        id(detail::thread_data_ptr thread_data_):

            thread_data(thread_data_)

        {}

        friend class thread;

        friend id this_thread::get_id();

    public:

        id():

            thread_data()

        {}

        bool operator==(const id& y) const

        {

            return thread_data==y.thread_data;

        }

        bool operator!=(const id& y) const

        {

            return thread_data!=y.thread_data;

        }

        bool operator<(const id& y) const

        {

            return thread_data<y.thread_data;

        }

        bool operator>(const id& y) const

        {

            return y.thread_data<thread_data;

        }

        bool operator<=(const id& y) const

        {

            return !(y.thread_data<thread_data);

        }

        bool operator>=(const id& y) const

        {

            return !(thread_data<y.thread_data);

        }

        template<class charT, class traits>

        friend std::basic_ostream<charT, traits>& 

        operator<<(std::basic_ostream<charT, traits>& os, const id& x)

        {

            if(x.thread_data)

            {

                return os<<x.thread_data;

            }

            else

            {

                return os<<"{Not-any-thread}";

            }

        }

    };

    inline bool thread::operator==(const thread& other) const

    {

        return get_id()==other.get_id();

    }

    inline bool thread::operator!=(const thread& other) const

    {

        return get_id()!=other.get_id();

    }

    namespace detail

    {

        struct thread_exit_function_base

        {

            virtual ~thread_exit_function_base()

            {}

            virtual void operator()() const=0;

        };

        template<typename F>

        struct thread_exit_function:

            thread_exit_function_base

        {

            F f;

            thread_exit_function(F f_):

                f(f_)

            {}

            void operator()() const

            {

                f();

            }

        };

        void add_thread_exit_function(thread_exit_function_base*);

    }

    namespace this_thread

    {

        template<typename F>

        void at_thread_exit(F f)

        {

            detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);

            detail::add_thread_exit_function(thread_exit_func);

        }

    }

    class thread_group:

        private noncopyable

    {

    public:

        ~thread_group()

        {

            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();

                it!=end;

                ++it)

            {

                delete *it;

            }

        }

        template<typename F>

        thread* create_thread(F threadfunc)

        {

            boost::lock_guard<mutex> guard(m);

            std::auto_ptr<thread> new_thread(new thread(threadfunc));

            threads.push_back(new_thread.get());

            return new_thread.release();

        }

        void add_thread(thread* thrd)

        {

            if(thrd)

            {

                boost::lock_guard<mutex> guard(m);

                threads.push_back(thrd);

            }

        }

        void remove_thread(thread* thrd)

        {

            boost::lock_guard<mutex> guard(m);

            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);

            if(it!=threads.end())

            {

                threads.erase(it);