Browse code

Updating pwiz to 3_0_21263

Steffen Neumann authored on 23/09/2021 12:34:25
Showing1 changed files
1 1
new file mode 100755
... ...
@@ -0,0 +1,170 @@
1
+// (C) Copyright 2012 Vicente J. Botet Escriba
2
+// Distributed under the Boost Software License, Version 1.0. (See
3
+// accompanying file LICENSE_1_0.txt or copy at
4
+// http://www.boost.org/LICENSE_1_0.txt)
5
+
6
+
7
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
+#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
+
10
+#include <boost/thread/detail/config.hpp>
11
+#include <boost/thread/detail/move.hpp>
12
+#include <boost/thread/detail/delete.hpp>
13
+
14
+#include <boost/thread/externally_locked.hpp>
15
+#include <boost/thread/lock_traits.hpp>
16
+#include <boost/thread/recursive_mutex.hpp>
17
+#include <boost/thread/strict_lock.hpp>
18
+
19
+#include <boost/config/abi_prefix.hpp>
20
+
21
+namespace boost
22
+{
23
+
24
+  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
+  class externally_locked_stream;
26
+
27
+  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
+  class stream_guard
29
+  {
30
+
31
+    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
+  public:
33
+    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
+
35
+    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
+
37
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
+      mtx_(&mtx)
39
+    {
40
+      mtx.lock();
41
+    }
42
+
43
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
+      mtx_(&mtx)
45
+    {
46
+    }
47
+
48
+    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
+    : mtx_(rhs.mtx_)
50
+    {
51
+      rhs.mtx_= 0;
52
+    }
53
+
54
+    ~stream_guard()
55
+    {
56
+      if (mtx_ != 0) mtx_->unlock();
57
+    }
58
+
59
+    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
+    {
61
+      return l == mtx_->mutex();
62
+    }
63
+
64
+    /**
65
+     * @Requires mtx_
66
+     */
67
+    Stream& get() const
68
+    {
69
+      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
+      return mtx_->get(*this);
71
+    }
72
+    Stream& bypass() const
73
+    {
74
+      return get();
75
+    }
76
+
77
+
78
+  private:
79
+    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
+  };
81
+
82
+  template <typename Stream, typename RecursiveMutex>
83
+  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
+  {
85
+  };
86
+
87
+  /**
88
+   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
+   * provides full access to that object through the get and set member functions, provided you
90
+   * pass a reference to a strict lock object.
91
+   */
92
+
93
+  //[externally_locked_stream
94
+  template <typename Stream, typename RecursiveMutex>
95
+  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
+  {
97
+    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
+  public:
99
+    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
+
101
+    /**
102
+     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
+     */
104
+    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
+      base_type(stream, mtx)
106
+    {
107
+    }
108
+
109
+    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
+    {
111
+      return stream_guard<Stream, RecursiveMutex> (*this);
112
+    }
113
+    Stream& bypass() const
114
+    {
115
+      stream_guard<Stream, RecursiveMutex> lk(*this);
116
+      return get(lk);
117
+    }
118
+  };
119
+  //]
120
+
121
+  template <typename Stream, typename RecursiveMutex, typename T>
122
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
+  {
124
+    lck.get() << arg;
125
+    return lck;
126
+  }
127
+
128
+  template <typename Stream, typename RecursiveMutex>
129
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
+  {
131
+    lck.get() << arg;
132
+    return lck;
133
+  }
134
+
135
+  template <typename Stream, typename RecursiveMutex, typename T>
136
+  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
+  {
138
+    lck.get() >> arg;
139
+    return lck;
140
+  }
141
+
142
+  template <typename Stream, typename RecursiveMutex, typename T>
143
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
+  {
145
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
+    mtx.get(lk) << arg;
147
+    return boost::move(lk);
148
+  }
149
+
150
+  template <typename Stream, typename RecursiveMutex>
151
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
+  {
153
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
+    mtx.get(lk) << arg;
155
+    return boost::move(lk);
156
+  }
157
+
158
+  template <typename Stream, typename RecursiveMutex, typename T>
159
+  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
+  {
161
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
+    mtx.get(lk) >> arg;
163
+    return boost::move(lk);
164
+  }
165
+
166
+}
167
+
168
+#include <boost/config/abi_suffix.hpp>
169
+
170
+#endif // header
Browse code

drop old boost

From: Steffen Neumann <sneumann@ipb-halle.de>

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@125184 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 15/12/2016 10:41:45
Showing1 changed files
1 1
deleted file mode 100644
... ...
@@ -1,170 +0,0 @@
1
-// (C) Copyright 2012 Vicente J. Botet Escriba
2
-// Distributed under the Boost Software License, Version 1.0. (See
3
-// accompanying file LICENSE_1_0.txt or copy at
4
-// http://www.boost.org/LICENSE_1_0.txt)
5
-
6
-
7
-#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
-#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
-
10
-#include <boost/thread/detail/config.hpp>
11
-#include <boost/thread/detail/move.hpp>
12
-#include <boost/thread/detail/delete.hpp>
13
-
14
-#include <boost/thread/externally_locked.hpp>
15
-#include <boost/thread/lock_traits.hpp>
16
-#include <boost/thread/recursive_mutex.hpp>
17
-#include <boost/thread/strict_lock.hpp>
18
-
19
-#include <boost/config/abi_prefix.hpp>
20
-
21
-namespace boost
22
-{
23
-
24
-  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
-  class externally_locked_stream;
26
-
27
-  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
-  class stream_guard
29
-  {
30
-
31
-    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
-  public:
33
-    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
-
35
-    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
-
37
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
-      mtx_(&mtx)
39
-    {
40
-      mtx.lock();
41
-    }
42
-
43
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
-      mtx_(&mtx)
45
-    {
46
-    }
47
-
48
-    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
-    : mtx_(rhs.mtx_)
50
-    {
51
-      rhs.mtx_= 0;
52
-    }
53
-
54
-    ~stream_guard()
55
-    {
56
-      if (mtx_ != 0) mtx_->unlock();
57
-    }
58
-
59
-    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
-    {
61
-      return l == mtx_->mutex();
62
-    }
63
-
64
-    /**
65
-     * @Requires mtx_
66
-     */
67
-    Stream& get() const
68
-    {
69
-      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
-      return mtx_->get(*this);
71
-    }
72
-    Stream& bypass() const
73
-    {
74
-      return get();
75
-    }
76
-
77
-
78
-  private:
79
-    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
-  };
81
-
82
-  template <typename Stream, typename RecursiveMutex>
83
-  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
-  {
85
-  };
86
-
87
-  /**
88
-   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
-   * provides full access to that object through the get and set member functions, provided you
90
-   * pass a reference to a strict lock object.
91
-   */
92
-
93
-  //[externally_locked_stream
94
-  template <typename Stream, typename RecursiveMutex>
95
-  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
-  {
97
-    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
-  public:
99
-    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
-
101
-    /**
102
-     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
-     */
104
-    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
-      base_type(stream, mtx)
106
-    {
107
-    }
108
-
109
-    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
-    {
111
-      return stream_guard<Stream, RecursiveMutex> (*this);
112
-    }
113
-    Stream& bypass() const
114
-    {
115
-      stream_guard<Stream, RecursiveMutex> lk(*this);
116
-      return get(lk);
117
-    }
118
-  };
119
-  //]
120
-
121
-  template <typename Stream, typename RecursiveMutex, typename T>
122
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
-  {
124
-    lck.get() << arg;
125
-    return lck;
126
-  }
127
-
128
-  template <typename Stream, typename RecursiveMutex>
129
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
-  {
131
-    lck.get() << arg;
132
-    return lck;
133
-  }
134
-
135
-  template <typename Stream, typename RecursiveMutex, typename T>
136
-  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
-  {
138
-    lck.get() >> arg;
139
-    return lck;
140
-  }
141
-
142
-  template <typename Stream, typename RecursiveMutex, typename T>
143
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
-  {
145
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
-    mtx.get(lk) << arg;
147
-    return boost::move(lk);
148
-  }
149
-
150
-  template <typename Stream, typename RecursiveMutex>
151
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
-  {
153
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
-    mtx.get(lk) << arg;
155
-    return boost::move(lk);
156
-  }
157
-
158
-  template <typename Stream, typename RecursiveMutex, typename T>
159
-  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
-  {
161
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
-    mtx.get(lk) >> arg;
163
-    return boost::move(lk);
164
-  }
165
-
166
-}
167
-
168
-#include <boost/config/abi_suffix.hpp>
169
-
170
-#endif // header
Browse code

checkout latest pwiz, ammend Makevars

From: Laurent <lg390@cam.ac.uk>

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@125180 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 15/12/2016 10:21:41
Showing1 changed files
... ...
@@ -1,170 +1,170 @@
1
-// (C) Copyright 2012 Vicente J. Botet Escriba
2
-// Distributed under the Boost Software License, Version 1.0. (See
3
-// accompanying file LICENSE_1_0.txt or copy at
4
-// http://www.boost.org/LICENSE_1_0.txt)
5
-
6
-
7
-#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
-#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
-
10
-#include <boost/thread/detail/config.hpp>
11
-#include <boost/thread/detail/move.hpp>
12
-#include <boost/thread/detail/delete.hpp>
13
-
14
-#include <boost/thread/externally_locked.hpp>
15
-#include <boost/thread/lock_traits.hpp>
16
-#include <boost/thread/recursive_mutex.hpp>
17
-#include <boost/thread/strict_lock.hpp>
18
-
19
-#include <boost/config/abi_prefix.hpp>
20
-
21
-namespace boost
22
-{
23
-
24
-  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
-  class externally_locked_stream;
26
-
27
-  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
-  class stream_guard
29
-  {
30
-
31
-    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
-  public:
33
-    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
-
35
-    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
-
37
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
-      mtx_(&mtx)
39
-    {
40
-      mtx.lock();
41
-    }
42
-
43
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
-      mtx_(&mtx)
45
-    {
46
-    }
47
-
48
-    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
-    : mtx_(rhs.mtx_)
50
-    {
51
-      rhs.mtx_= 0;
52
-    }
53
-
54
-    ~stream_guard()
55
-    {
56
-      if (mtx_ != 0) mtx_->unlock();
57
-    }
58
-
59
-    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
-    {
61
-      return l == mtx_->mutex();
62
-    }
63
-
64
-    /**
65
-     * @Requires mtx_
66
-     */
67
-    Stream& get() const
68
-    {
69
-      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
-      return mtx_->get(*this);
71
-    }
72
-    Stream& bypass() const
73
-    {
74
-      return get();
75
-    }
76
-
77
-
78
-  private:
79
-    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
-  };
81
-
82
-  template <typename Stream, typename RecursiveMutex>
83
-  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
-  {
85
-  };
86
-
87
-  /**
88
-   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
-   * provides full access to that object through the get and set member functions, provided you
90
-   * pass a reference to a strict lock object.
91
-   */
92
-
93
-  //[externally_locked_stream
94
-  template <typename Stream, typename RecursiveMutex>
95
-  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
-  {
97
-    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
-  public:
99
-    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
-
101
-    /**
102
-     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
-     */
104
-    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
-      base_type(stream, mtx)
106
-    {
107
-    }
108
-
109
-    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
-    {
111
-      return stream_guard<Stream, RecursiveMutex> (*this);
112
-    }
113
-    Stream& bypass() const
114
-    {
115
-      stream_guard<Stream, RecursiveMutex> lk(*this);
116
-      return get(lk);
117
-    }
118
-  };
119
-  //]
120
-
121
-  template <typename Stream, typename RecursiveMutex, typename T>
122
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
-  {
124
-    lck.get() << arg;
125
-    return lck;
126
-  }
127
-
128
-  template <typename Stream, typename RecursiveMutex>
129
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
-  {
131
-    lck.get() << arg;
132
-    return lck;
133
-  }
134
-
135
-  template <typename Stream, typename RecursiveMutex, typename T>
136
-  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
-  {
138
-    lck.get() >> arg;
139
-    return lck;
140
-  }
141
-
142
-  template <typename Stream, typename RecursiveMutex, typename T>
143
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
-  {
145
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
-    mtx.get(lk) << arg;
147
-    return boost::move(lk);
148
-  }
149
-
150
-  template <typename Stream, typename RecursiveMutex>
151
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
-  {
153
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
-    mtx.get(lk) << arg;
155
-    return boost::move(lk);
156
-  }
157
-
158
-  template <typename Stream, typename RecursiveMutex, typename T>
159
-  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
-  {
161
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
-    mtx.get(lk) >> arg;
163
-    return boost::move(lk);
164
-  }
165
-
166
-}
167
-
168
-#include <boost/config/abi_suffix.hpp>
169
-
170
-#endif // header
1
+// (C) Copyright 2012 Vicente J. Botet Escriba
2
+// Distributed under the Boost Software License, Version 1.0. (See
3
+// accompanying file LICENSE_1_0.txt or copy at
4
+// http://www.boost.org/LICENSE_1_0.txt)
5
+
6
+
7
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
+#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
+
10
+#include <boost/thread/detail/config.hpp>
11
+#include <boost/thread/detail/move.hpp>
12
+#include <boost/thread/detail/delete.hpp>
13
+
14
+#include <boost/thread/externally_locked.hpp>
15
+#include <boost/thread/lock_traits.hpp>
16
+#include <boost/thread/recursive_mutex.hpp>
17
+#include <boost/thread/strict_lock.hpp>
18
+
19
+#include <boost/config/abi_prefix.hpp>
20
+
21
+namespace boost
22
+{
23
+
24
+  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
+  class externally_locked_stream;
26
+
27
+  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
+  class stream_guard
29
+  {
30
+
31
+    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
+  public:
33
+    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
+
35
+    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
+
37
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
+      mtx_(&mtx)
39
+    {
40
+      mtx.lock();
41
+    }
42
+
43
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
+      mtx_(&mtx)
45
+    {
46
+    }
47
+
48
+    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
+    : mtx_(rhs.mtx_)
50
+    {
51
+      rhs.mtx_= 0;
52
+    }
53
+
54
+    ~stream_guard()
55
+    {
56
+      if (mtx_ != 0) mtx_->unlock();
57
+    }
58
+
59
+    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
+    {
61
+      return l == mtx_->mutex();
62
+    }
63
+
64
+    /**
65
+     * @Requires mtx_
66
+     */
67
+    Stream& get() const
68
+    {
69
+      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
+      return mtx_->get(*this);
71
+    }
72
+    Stream& bypass() const
73
+    {
74
+      return get();
75
+    }
76
+
77
+
78
+  private:
79
+    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
+  };
81
+
82
+  template <typename Stream, typename RecursiveMutex>
83
+  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
+  {
85
+  };
86
+
87
+  /**
88
+   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
+   * provides full access to that object through the get and set member functions, provided you
90
+   * pass a reference to a strict lock object.
91
+   */
92
+
93
+  //[externally_locked_stream
94
+  template <typename Stream, typename RecursiveMutex>
95
+  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
+  {
97
+    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
+  public:
99
+    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
+
101
+    /**
102
+     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
+     */
104
+    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
+      base_type(stream, mtx)
106
+    {
107
+    }
108
+
109
+    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
+    {
111
+      return stream_guard<Stream, RecursiveMutex> (*this);
112
+    }
113
+    Stream& bypass() const
114
+    {
115
+      stream_guard<Stream, RecursiveMutex> lk(*this);
116
+      return get(lk);
117
+    }
118
+  };
119
+  //]
120
+
121
+  template <typename Stream, typename RecursiveMutex, typename T>
122
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
+  {
124
+    lck.get() << arg;
125
+    return lck;
126
+  }
127
+
128
+  template <typename Stream, typename RecursiveMutex>
129
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
+  {
131
+    lck.get() << arg;
132
+    return lck;
133
+  }
134
+
135
+  template <typename Stream, typename RecursiveMutex, typename T>
136
+  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
+  {
138
+    lck.get() >> arg;
139
+    return lck;
140
+  }
141
+
142
+  template <typename Stream, typename RecursiveMutex, typename T>
143
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
+  {
145
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
+    mtx.get(lk) << arg;
147
+    return boost::move(lk);
148
+  }
149
+
150
+  template <typename Stream, typename RecursiveMutex>
151
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
+  {
153
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
+    mtx.get(lk) << arg;
155
+    return boost::move(lk);
156
+  }
157
+
158
+  template <typename Stream, typename RecursiveMutex, typename T>
159
+  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
+  {
161
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
+    mtx.get(lk) >> arg;
163
+    return boost::move(lk);
164
+  }
165
+
166
+}
167
+
168
+#include <boost/config/abi_suffix.hpp>
169
+
170
+#endif // header
Browse code

Commit made by the Bioconductor Git-SVN bridge.

Commit id: 0b3d4d9bb71e3ca5891b777610fc8dec103a6d61

Bumped version after KK's updates


Commit id: 9e04409b64757a177893d56c0300904f31945cb1

modified: src/pwiz/data/common/BinaryIndexStream.cpp modified: src/win/i386/libpwiz.a modified: src/win/x64/libpwiz.a


Commit id: f16b04258dc20bf3315beac99708e11728cfc12b

update precompiled lib for windows


Commit id: 5d56197f1148378d92e89b2d0a167e18c4b7ab2e

Bump version, tame .Rbuildignore


Commit id: 432da5bd294c9b87f7761e15bc814c3785c21abf

Merge remote-tracking branch 'origin/boost_159'


Commit id: 92be978bf72d90c2222a19ddf365f6d1acc9f20d

upadte Makevars


Commit id: ae75037a780cead56c4d20bedf822c94fb413677

upgrade to boost 1.5.9



git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@110126 bc3139a8-67e5-0310-9ffc-ced21a209358

s.neumann authored on 01/11/2015 22:33:47
Showing1 changed files
... ...
@@ -1,170 +1,170 @@
1
-// (C) Copyright 2012 Vicente J. Botet Escriba
2
-// Distributed under the Boost Software License, Version 1.0. (See
3
-// accompanying file LICENSE_1_0.txt or copy at
4
-// http://www.boost.org/LICENSE_1_0.txt)
5
-
6
-
7
-#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
-#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
-
10
-#include <boost/thread/detail/config.hpp>
11
-#include <boost/thread/detail/move.hpp>
12
-#include <boost/thread/detail/delete.hpp>
13
-
14
-#include <boost/thread/externally_locked.hpp>
15
-#include <boost/thread/lock_traits.hpp>
16
-#include <boost/thread/recursive_mutex.hpp>
17
-#include <boost/thread/strict_lock.hpp>
18
-
19
-#include <boost/config/abi_prefix.hpp>
20
-
21
-namespace boost
22
-{
23
-
24
-  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
-  class externally_locked_stream;
26
-
27
-  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
-  class stream_guard
29
-  {
30
-
31
-    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
-  public:
33
-    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
-
35
-    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
-
37
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
-      mtx_(&mtx)
39
-    {
40
-      mtx.lock();
41
-    }
42
-
43
-    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
-      mtx_(&mtx)
45
-    {
46
-    }
47
-
48
-    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
-    : mtx_(rhs.mtx_)
50
-    {
51
-      rhs.mtx_= 0;
52
-    }
53
-
54
-    ~stream_guard()
55
-    {
56
-      if (mtx_ != 0) mtx_->unlock();
57
-    }
58
-
59
-    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
-    {
61
-      return l == mtx_->mutex();
62
-    }
63
-
64
-    /**
65
-     * @Requires mtx_
66
-     */
67
-    Stream& get() const
68
-    {
69
-      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
-      return mtx_->get(*this);
71
-    }
72
-    Stream& bypass() const
73
-    {
74
-      return get();
75
-    }
76
-
77
-
78
-  private:
79
-    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
-  };
81
-
82
-  template <typename Stream, typename RecursiveMutex>
83
-  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
-  {
85
-  };
86
-
87
-  /**
88
-   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
-   * provides full access to that object through the get and set member functions, provided you
90
-   * pass a reference to a strict lock object.
91
-   */
92
-
93
-  //[externally_locked_stream
94
-  template <typename Stream, typename RecursiveMutex>
95
-  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
-  {
97
-    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
-  public:
99
-    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
-
101
-    /**
102
-     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
-     */
104
-    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
-      base_type(stream, mtx)
106
-    {
107
-    }
108
-
109
-    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
-    {
111
-      return stream_guard<Stream, RecursiveMutex> (*this);
112
-    }
113
-    Stream& bypass() const
114
-    {
115
-      stream_guard<Stream, RecursiveMutex> lk(*this);
116
-      return get(lk);
117
-    }
118
-  };
119
-  //]
120
-
121
-  template <typename Stream, typename RecursiveMutex, typename T>
122
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
-  {
124
-    lck.get() << arg;
125
-    return lck;
126
-  }
127
-
128
-  template <typename Stream, typename RecursiveMutex>
129
-  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
-  {
131
-    lck.get() << arg;
132
-    return lck;
133
-  }
134
-
135
-  template <typename Stream, typename RecursiveMutex, typename T>
136
-  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
-  {
138
-    lck.get() >> arg;
139
-    return lck;
140
-  }
141
-
142
-  template <typename Stream, typename RecursiveMutex, typename T>
143
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
-  {
145
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
-    mtx.get(lk) << arg;
147
-    return boost::move(lk);
148
-  }
149
-
150
-  template <typename Stream, typename RecursiveMutex>
151
-  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
-  {
153
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
-    mtx.get(lk) << arg;
155
-    return boost::move(lk);
156
-  }
157
-
158
-  template <typename Stream, typename RecursiveMutex, typename T>
159
-  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
-  {
161
-    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
-    mtx.get(lk) >> arg;
163
-    return boost::move(lk);
164
-  }
165
-
166
-}
167
-
168
-#include <boost/config/abi_suffix.hpp>
169
-
170
-#endif // header
1
+// (C) Copyright 2012 Vicente J. Botet Escriba
2
+// Distributed under the Boost Software License, Version 1.0. (See
3
+// accompanying file LICENSE_1_0.txt or copy at
4
+// http://www.boost.org/LICENSE_1_0.txt)
5
+
6
+
7
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
+#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
+
10
+#include <boost/thread/detail/config.hpp>
11
+#include <boost/thread/detail/move.hpp>
12
+#include <boost/thread/detail/delete.hpp>
13
+
14
+#include <boost/thread/externally_locked.hpp>
15
+#include <boost/thread/lock_traits.hpp>
16
+#include <boost/thread/recursive_mutex.hpp>
17
+#include <boost/thread/strict_lock.hpp>
18
+
19
+#include <boost/config/abi_prefix.hpp>
20
+
21
+namespace boost
22
+{
23
+
24
+  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
+  class externally_locked_stream;
26
+
27
+  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
+  class stream_guard
29
+  {
30
+
31
+    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
+  public:
33
+    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
+
35
+    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
+
37
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
+      mtx_(&mtx)
39
+    {
40
+      mtx.lock();
41
+    }
42
+
43
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
+      mtx_(&mtx)
45
+    {
46
+    }
47
+
48
+    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
+    : mtx_(rhs.mtx_)
50
+    {
51
+      rhs.mtx_= 0;
52
+    }
53
+
54
+    ~stream_guard()
55
+    {
56
+      if (mtx_ != 0) mtx_->unlock();
57
+    }
58
+
59
+    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
+    {
61
+      return l == mtx_->mutex();
62
+    }
63
+
64
+    /**
65
+     * @Requires mtx_
66
+     */
67
+    Stream& get() const
68
+    {
69
+      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
+      return mtx_->get(*this);
71
+    }
72
+    Stream& bypass() const
73
+    {
74
+      return get();
75
+    }
76
+
77
+
78
+  private:
79
+    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
+  };
81
+
82
+  template <typename Stream, typename RecursiveMutex>
83
+  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
+  {
85
+  };
86
+
87
+  /**
88
+   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
+   * provides full access to that object through the get and set member functions, provided you
90
+   * pass a reference to a strict lock object.
91
+   */
92
+
93
+  //[externally_locked_stream
94
+  template <typename Stream, typename RecursiveMutex>
95
+  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
+  {
97
+    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
+  public:
99
+    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
+
101
+    /**
102
+     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
+     */
104
+    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
+      base_type(stream, mtx)
106
+    {
107
+    }
108
+
109
+    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
+    {
111
+      return stream_guard<Stream, RecursiveMutex> (*this);
112
+    }
113
+    Stream& bypass() const
114
+    {
115
+      stream_guard<Stream, RecursiveMutex> lk(*this);
116
+      return get(lk);
117
+    }
118
+  };
119
+  //]
120
+
121
+  template <typename Stream, typename RecursiveMutex, typename T>
122
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
+  {
124
+    lck.get() << arg;
125
+    return lck;
126
+  }
127
+
128
+  template <typename Stream, typename RecursiveMutex>
129
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
+  {
131
+    lck.get() << arg;
132
+    return lck;
133
+  }
134
+
135
+  template <typename Stream, typename RecursiveMutex, typename T>
136
+  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
+  {
138
+    lck.get() >> arg;
139
+    return lck;
140
+  }
141
+
142
+  template <typename Stream, typename RecursiveMutex, typename T>
143
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
+  {
145
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
+    mtx.get(lk) << arg;
147
+    return boost::move(lk);
148
+  }
149
+
150
+  template <typename Stream, typename RecursiveMutex>
151
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
+  {
153
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
+    mtx.get(lk) << arg;
155
+    return boost::move(lk);
156
+  }
157
+
158
+  template <typename Stream, typename RecursiveMutex, typename T>
159
+  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
+  {
161
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
+    mtx.get(lk) >> arg;
163
+    return boost::move(lk);
164
+  }
165
+
166
+}
167
+
168
+#include <boost/config/abi_suffix.hpp>
169
+
170
+#endif // header
Browse code

adding missing files

git-svn-id: https://hedgehog.fhcrc.org/bioconductor/trunk/madman/Rpacks/mzR@90759 bc3139a8-67e5-0310-9ffc-ced21a209358

l.gatto authored on 28/05/2014 00:29:07
Showing1 changed files
1 1
new file mode 100644
... ...
@@ -0,0 +1,170 @@
1
+// (C) Copyright 2012 Vicente J. Botet Escriba
2
+// Distributed under the Boost Software License, Version 1.0. (See
3
+// accompanying file LICENSE_1_0.txt or copy at
4
+// http://www.boost.org/LICENSE_1_0.txt)
5
+
6
+
7
+#ifndef BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
8
+#define BOOST_THREAD_EXTERNALLY_LOCKED_STREAM_HPP
9
+
10
+#include <boost/thread/detail/config.hpp>
11
+#include <boost/thread/detail/move.hpp>
12
+#include <boost/thread/detail/delete.hpp>
13
+
14
+#include <boost/thread/externally_locked.hpp>
15
+#include <boost/thread/lock_traits.hpp>
16
+#include <boost/thread/recursive_mutex.hpp>
17
+#include <boost/thread/strict_lock.hpp>
18
+
19
+#include <boost/config/abi_prefix.hpp>
20
+
21
+namespace boost
22
+{
23
+
24
+  template <typename Stream, typename RecursiveMutex=recursive_mutex>
25
+  class externally_locked_stream;
26
+
27
+  template <class Stream, typename RecursiveMutex=recursive_mutex>
28
+  class stream_guard
29
+  {
30
+
31
+    friend class externally_locked_stream<Stream, RecursiveMutex> ;
32
+  public:
33
+    typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
34
+
35
+    BOOST_THREAD_MOVABLE_ONLY( stream_guard)
36
+
37
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
38
+      mtx_(&mtx)
39
+    {
40
+      mtx.lock();
41
+    }
42
+
43
+    stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
44
+      mtx_(&mtx)
45
+    {
46
+    }
47
+
48
+    stream_guard(BOOST_THREAD_RV_REF(stream_guard) rhs) BOOST_NOEXCEPT
49
+    : mtx_(rhs.mtx_)
50
+    {
51
+      rhs.mtx_= 0;
52
+    }
53
+
54
+    ~stream_guard()
55
+    {
56
+      if (mtx_ != 0) mtx_->unlock();
57
+    }
58
+
59
+    bool owns_lock(const mutex_type * l) const BOOST_NOEXCEPT
60
+    {
61
+      return l == mtx_->mutex();
62
+    }
63
+
64
+    /**
65
+     * @Requires mtx_
66
+     */
67
+    Stream& get() const
68
+    {
69
+      BOOST_THREAD_ASSERT_PRECONDITION(  mtx_, lock_error() );
70
+      return mtx_->get(*this);
71
+    }
72
+    Stream& bypass() const
73
+    {
74
+      return get();
75
+    }
76
+
77
+
78
+  private:
79
+    externally_locked_stream<Stream, RecursiveMutex>* mtx_;
80
+  };
81
+
82
+  template <typename Stream, typename RecursiveMutex>
83
+  struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
84
+  {
85
+  };
86
+
87
+  /**
88
+   * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
89
+   * provides full access to that object through the get and set member functions, provided you
90
+   * pass a reference to a strict lock object.
91
+   */
92
+
93
+  //[externally_locked_stream
94
+  template <typename Stream, typename RecursiveMutex>
95
+  class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
96
+  {
97
+    typedef externally_locked<Stream&, RecursiveMutex> base_type;
98
+  public:
99
+    BOOST_THREAD_NO_COPYABLE( externally_locked_stream)
100
+
101
+    /**
102
+     * Effects: Constructs an externally locked object storing the cloaked reference object.
103
+     */
104
+    externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
105
+      base_type(stream, mtx)
106
+    {
107
+    }
108
+
109
+    stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
110
+    {
111
+      return stream_guard<Stream, RecursiveMutex> (*this);
112
+    }
113
+    Stream& bypass() const
114
+    {
115
+      stream_guard<Stream, RecursiveMutex> lk(*this);
116
+      return get(lk);
117
+    }
118
+  };
119
+  //]
120
+
121
+  template <typename Stream, typename RecursiveMutex, typename T>
122
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
123
+  {
124
+    lck.get() << arg;
125
+    return lck;
126
+  }
127
+
128
+  template <typename Stream, typename RecursiveMutex>
129
+  inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
130
+  {
131
+    lck.get() << arg;
132
+    return lck;
133
+  }
134
+
135
+  template <typename Stream, typename RecursiveMutex, typename T>
136
+  inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
137
+  {
138
+    lck.get() >> arg;
139
+    return lck;
140
+  }
141
+
142
+  template <typename Stream, typename RecursiveMutex, typename T>
143
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
144
+  {
145
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
146
+    mtx.get(lk) << arg;
147
+    return boost::move(lk);
148
+  }
149
+
150
+  template <typename Stream, typename RecursiveMutex>
151
+  inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
152
+  {
153
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
154
+    mtx.get(lk) << arg;
155
+    return boost::move(lk);
156
+  }
157
+
158
+  template <typename Stream, typename RecursiveMutex, typename T>
159
+  inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
160
+  {
161
+    stream_guard<Stream, RecursiveMutex> lk(mtx);
162
+    mtx.get(lk) >> arg;
163
+    return boost::move(lk);
164
+  }
165
+
166
+}
167
+
168
+#include <boost/config/abi_suffix.hpp>
169
+
170
+#endif // header