← Back to branch summary

~ubuntu-branches/ubuntu/wily/davix/wily

« back to all changes in this revision

Viewing changes to deps/boost_intern/boost/thread/detail/thread_group.hpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2015-07-31 13:17:55 UTC
  • mfrom: (5.1.3 sid)
  • Revision ID: package-import@ubuntu.com-20150731131755-mizprbmn7ogv33te
Tags: 0.4.1-1
* Update to version 0.4.1
* Implement Multi-Arch support

Show diffs side-by-side

added added

removed removed

Lines of Context:
deps/boost_intern/boost/thread/detail/thread_group.hpp
1
 
#ifndef BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
2
 
#define BOOST_THREAD_DETAIL_THREAD_GROUP_HPP
3
 
// Distributed under the Boost Software License, Version 1.0. (See
4
 
// accompanying file LICENSE_1_0.txt or copy at
5
 
// http://www.boost.org/LICENSE_1_0.txt)
6
 
// (C) Copyright 2007-9 Anthony Williams
7
 
 
8
 
#include <list>
9
 
#include <boost/thread/shared_mutex.hpp>
10
 
#include <boost/thread/mutex.hpp>
11
 
#include <boost/thread/lock_guard.hpp>
12
 
 
13
 
#include <boost/config/abi_prefix.hpp>
14
 
 
15
 
#ifdef BOOST_MSVC
16
 
#pragma warning(push)
17
 
#pragma warning(disable:4251)
18
 
#endif
19
 
 
20
 
namespace boost
21
 
{
22
 
    class thread_group
23
 
    {
24
 
    private:
25
 
        thread_group(thread_group const&);
26
 
        thread_group& operator=(thread_group const&);
27
 
    public:
28
 
        thread_group() {}
29
 
        ~thread_group()
30
 
        {
31
 
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
32
 
                it!=end;
33
 
                ++it)
34
 
            {
35
 
                delete *it;
36
 
            }
37
 
        }
38
 
 
39
 
        bool is_this_thread_in()
40
 
        {
41
 
            thread::id id = this_thread::get_id();
42
 
            boost::shared_lock<shared_mutex> guard(m);
43
 
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
44
 
                it!=end;
45
 
                ++it)
46
 
            {
47
 
              if ((*it)->get_id() == id)
48
 
                return true;
49
 
            }
50
 
            return false;
51
 
        }
52
 
 
53
 
        bool is_thread_in(thread* thrd)
54
 
        {
55
 
          if(thrd)
56
 
          {
57
 
            thread::id id = thrd->get_id();
58
 
            boost::shared_lock<shared_mutex> guard(m);
59
 
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
60
 
                it!=end;
61
 
                ++it)
62
 
            {
63
 
              if ((*it)->get_id() == id)
64
 
                return true;
65
 
            }
66
 
            return false;
67
 
          }
68
 
          else
69
 
          {
70
 
            return false;
71
 
          }
72
 
        }
73
 
 
74
 
        template<typename F>
75
 
        thread* create_thread(F threadfunc)
76
 
        {
77
 
            boost::lock_guard<shared_mutex> guard(m);
78
 
            std::auto_ptr<thread> new_thread(new thread(threadfunc));
79
 
            threads.push_back(new_thread.get());
80
 
            return new_thread.release();
81
 
        }
82
 
 
83
 
        void add_thread(thread* thrd)
84
 
        {
85
 
            if(thrd)
86
 
            {
87
 
                BOOST_THREAD_ASSERT_PRECONDITION( ! is_thread_in(thrd) ,
88
 
                    thread_resource_error(system::errc::resource_deadlock_would_occur, "boost::thread_group: trying to add a duplicated thread")
89
 
                );
90
 
 
91
 
                boost::lock_guard<shared_mutex> guard(m);
92
 
                threads.push_back(thrd);
93
 
            }
94
 
        }
95
 
 
96
 
        void remove_thread(thread* thrd)
97
 
        {
98
 
            boost::lock_guard<shared_mutex> guard(m);
99
 
            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
100
 
            if(it!=threads.end())
101
 
            {
102
 
                threads.erase(it);
103
 
            }
104
 
        }
105
 
 
106
 
        void join_all()
107
 
        {
108
 
            BOOST_THREAD_ASSERT_PRECONDITION( ! is_this_thread_in() ,
109
 
                thread_resource_error(system::errc::resource_deadlock_would_occur, "boost::thread_group: trying joining itself")
110
 
            );
111
 
            boost::shared_lock<shared_mutex> guard(m);
112
 
 
113
 
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
114
 
                it!=end;
115
 
                ++it)
116
 
            {
117
 
              if ((*it)->joinable())
118
 
                (*it)->join();
119
 
            }
120
 
        }
121
 
 
122
 
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
123
 
        void interrupt_all()
124
 
        {
125
 
            boost::shared_lock<shared_mutex> guard(m);
126
 
 
127
 
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
128
 
                it!=end;
129
 
                ++it)
130
 
            {
131
 
                (*it)->interrupt();
132
 
            }
133
 
        }
134
 
#endif
135
 
 
136
 
        size_t size() const
137
 
        {
138
 
            boost::shared_lock<shared_mutex> guard(m);
139
 
            return threads.size();
140
 
        }
141
 
 
142
 
    private:
143
 
        std::list<thread*> threads;
144
 
        mutable shared_mutex m;
145
 
    };
146
 
}
147
 
 
148
 
#ifdef BOOST_MSVC
149
 
#pragma warning(pop)
150
 
#endif
151
 
 
152
 
#include <boost/config/abi_suffix.hpp>
153
 
 
154
 
#endif