Import.

author: Remko Tronçon <git@el-tramo.be> 2009-06-01 08:48:42 (GMT)
committer: Remko Tronçon <git@el-tramo.be> 2009-06-01 09:24:28 (GMT)
commit: 2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
tree: d46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/thread/detail/thread.hpp
download: swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip
swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2
1 files changed, 575 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/thread/detail/thread.hpp b/3rdParty/Boost/boost/thread/detail/thread.hpp
new file mode 100644
index 0000000..fbb895d
--- /dev/null
+++ b/3rdParty/Boost/boost/thread/detail/thread.hpp
@@ -0,0 +1,575 @@
+#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);
+            }
+        }
+        
+        void join_all()
+        {
+            boost::lock_guard<mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->join();
+            }
+        }
+        
+        void interrupt_all()
+        {
+            boost::lock_guard<mutex> guard(m);
+            
+            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
+                it!=end;
+                ++it)
+            {
+                (*it)->interrupt();
+            }
+        }
+        
+        size_t size() const
+        {
+            boost::lock_guard<mutex> guard(m);
+            return threads.size();
+        }
+        
+    private:
+        std::list<thread*> threads;
+        mutable mutex m;
+    };
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp>
+
+#endif
author	Remko Tronçon <git@el-tramo.be>	2009-06-01 08:48:42 (GMT)
committer	Remko Tronçon <git@el-tramo.be>	2009-06-01 09:24:28 (GMT)
commit	2812bddd81f8a1b804c7460f4e14cd0aa393d129 (patch)
tree	d46294f35150c4f0f43deaf2d31fceaf945ae715 /3rdParty/Boost/boost/thread/detail/thread.hpp
download	swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.zip swift-contrib-2812bddd81f8a1b804c7460f4e14cd0aa393d129.tar.bz2