[ceph.git] / ceph / src / boost / libs / thread / include / boost / thread / concurrent_queues / queue_base.hpp

#ifndef BOOST_THREAD_QUEUE_BASE_HPP
#define BOOST_THREAD_QUEUE_BASE_HPP

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Vicente J. Botet Escriba 2014. 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)
//
// See http://www.boost.org/libs/thread for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#include <boost/thread/detail/config.hpp>
#include <boost/thread/detail/move.hpp>
#include <boost/thread/concurrent_queues/queue_op_status.hpp>
#include <boost/type_traits/conditional.hpp>
#include <boost/type_traits/is_copy_constructible.hpp>


#include <boost/config/abi_prefix.hpp>

namespace boost
{
namespace concurrent
{
namespace detail
{

  template <typename ValueType, class SizeType>
  class queue_base_copyable_only
  {
  public:
    typedef ValueType value_type;
    typedef SizeType size_type;

    // Constructors/Assignment/Destructors
    virtual ~queue_base_copyable_only() {};

    // Observers
    virtual bool empty() const = 0;
    virtual bool full() const = 0;
    virtual size_type size() const = 0;
    virtual bool closed() const = 0;

    // Modifiers
    virtual void close() = 0;

    virtual void push(const value_type& x) = 0;

    virtual void pull(value_type&) = 0;
    virtual value_type pull() = 0;

    virtual queue_op_status try_push(const value_type& x) = 0;
    virtual queue_op_status try_pull(value_type&) = 0;

    virtual queue_op_status nonblocking_push(const value_type& x) = 0;
    virtual queue_op_status nonblocking_pull(value_type&) = 0;

    virtual queue_op_status wait_push(const value_type& x) = 0;
    virtual queue_op_status wait_pull(ValueType& elem) = 0;

  };

  template <typename ValueType, class SizeType>
  class queue_base_movable_only
  {
  public:
    typedef ValueType value_type;
    typedef SizeType size_type;
    // Constructors/Assignment/Destructors
    virtual ~queue_base_movable_only() {};

    // Observers
    virtual bool empty() const = 0;
    virtual bool full() const = 0;
    virtual size_type size() const = 0;
    virtual bool closed() const = 0;

    // Modifiers
    virtual void close() = 0;

    virtual void pull(value_type&) = 0;
    // enable_if is_nothrow_movable<value_type>
    virtual value_type pull() = 0;

    virtual queue_op_status try_pull(value_type&) = 0;

    virtual queue_op_status nonblocking_pull(value_type&) = 0;

    virtual queue_op_status wait_pull(value_type& elem) = 0;

    virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
  };


  template <typename ValueType, class SizeType>
  class queue_base_copyable_and_movable
  {
  public:
    typedef ValueType value_type;
    typedef SizeType size_type;
    // Constructors/Assignment/Destructors
    virtual ~queue_base_copyable_and_movable() {};


    // Observers
    virtual bool empty() const = 0;
    virtual bool full() const = 0;
    virtual size_type size() const = 0;
    virtual bool closed() const = 0;

    // Modifiers
    virtual void close() = 0;

    virtual void push(const value_type& x) = 0;

    virtual void pull(value_type&) = 0;
    // enable_if is_nothrow_copy_movable<value_type>
    virtual value_type pull() = 0;

    virtual queue_op_status try_push(const value_type& x) = 0;
    virtual queue_op_status try_pull(value_type&) = 0;

    virtual queue_op_status nonblocking_push(const value_type& x) = 0;
    virtual queue_op_status nonblocking_pull(value_type&) = 0;

    virtual queue_op_status wait_push(const value_type& x) = 0;
    virtual queue_op_status wait_pull(value_type& elem) = 0;

    virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
    virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
  };

  template <class T, class ST,
#if ! defined  BOOST_NO_CXX11_RVALUE_REFERENCES
#if defined __GNUC__ && ! defined __clang__
#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5) || !defined(__GXX_EXPERIMENTAL_CXX0X__)
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif // __GNUC__
#elif defined _MSC_VER
#if _MSC_VER < 1700
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = true
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif // _MSC_VER
#else
          bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
          bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
#endif
#else
          bool Copyable = is_copy_constructible<T>::value,
          bool Movable = has_move_emulation_enabled<T>::value
#endif
      >
  struct queue_base;

  template <class T, class ST>
  struct queue_base<T, ST, true, true> {
    typedef queue_base_copyable_and_movable<T, ST> type;
  };
  template <class T, class ST>
  struct queue_base<T, ST, true, false> {
    typedef queue_base_copyable_only<T, ST> type;
  };
  template <class T, class ST>
  struct queue_base<T, ST, false, true> {
    typedef queue_base_movable_only<T, ST> type;
  };

}

  template <typename ValueType, class SizeType=std::size_t>
  class queue_base :
    public detail::queue_base<ValueType, SizeType>::type
  {
  public:
      typedef ValueType value_type;
      typedef SizeType size_type;
    // Constructors/Assignment/Destructors
    virtual ~queue_base() {};
  };

}
using concurrent::queue_base;

}

#include <boost/config/abi_suffix.hpp>

#endif
Commit	Line	Data
7c673cae FG	1	#ifndef BOOST_THREAD_QUEUE_BASE_HPP
	2	#define BOOST_THREAD_QUEUE_BASE_HPP
	3
	4	//////////////////////////////////////////////////////////////////////////////
	5	//
	6	// (C) Copyright Vicente J. Botet Escriba 2014. Distributed under the Boost
	7	// Software License, Version 1.0. (See accompanying file
	8	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	9	//
	10	// See http://www.boost.org/libs/thread for documentation.
	11	//
	12	//////////////////////////////////////////////////////////////////////////////
	13
	14	#include <boost/thread/detail/config.hpp>
	15	#include <boost/thread/detail/move.hpp>
	16	#include <boost/thread/concurrent_queues/queue_op_status.hpp>
	17	#include <boost/type_traits/conditional.hpp>
	18	#include <boost/type_traits/is_copy_constructible.hpp>
	19
	20
	21	#include <boost/config/abi_prefix.hpp>
	22
	23	namespace boost
	24	{
	25	namespace concurrent
	26	{
	27	namespace detail
	28	{
	29
	30	template <typename ValueType, class SizeType>
	31	class queue_base_copyable_only
	32	{
	33	public:
	34	typedef ValueType value_type;
	35	typedef SizeType size_type;
	36
	37	// Constructors/Assignment/Destructors
	38	virtual ~queue_base_copyable_only() {};
	39
	40	// Observers
	41	virtual bool empty() const = 0;
	42	virtual bool full() const = 0;
	43	virtual size_type size() const = 0;
	44	virtual bool closed() const = 0;
	45
	46	// Modifiers
	47	virtual void close() = 0;
	48
	49	virtual void push(const value_type& x) = 0;
	50
	51	virtual void pull(value_type&) = 0;
	52	virtual value_type pull() = 0;
	53
	54	virtual queue_op_status try_push(const value_type& x) = 0;
	55	virtual queue_op_status try_pull(value_type&) = 0;
	56
	57	virtual queue_op_status nonblocking_push(const value_type& x) = 0;
	58	virtual queue_op_status nonblocking_pull(value_type&) = 0;
	59
	60	virtual queue_op_status wait_push(const value_type& x) = 0;
	61	virtual queue_op_status wait_pull(ValueType& elem) = 0;
	62
	63	};
	64
65	template <typename ValueType, class SizeType>
66	class queue_base_movable_only
67	{
68	public:
69	typedef ValueType value_type;
70	typedef SizeType size_type;
71	// Constructors/Assignment/Destructors
72	virtual ~queue_base_movable_only() {};
73
74	// Observers
75	virtual bool empty() const = 0;
76	virtual bool full() const = 0;
77	virtual size_type size() const = 0;
78	virtual bool closed() const = 0;
79
80	// Modifiers
81	virtual void close() = 0;
82
83	virtual void pull(value_type&) = 0;
84	// enable_if is_nothrow_movable<value_type>
85	virtual value_type pull() = 0;
86
87	virtual queue_op_status try_pull(value_type&) = 0;
88
89	virtual queue_op_status nonblocking_pull(value_type&) = 0;
90
91	virtual queue_op_status wait_pull(value_type& elem) = 0;
92
93	virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
94	virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
95	virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
96	virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
97	};
98
99
100	template <typename ValueType, class SizeType>
101	class queue_base_copyable_and_movable
102	{
103	public:
104	typedef ValueType value_type;
105	typedef SizeType size_type;
106	// Constructors/Assignment/Destructors
107	virtual ~queue_base_copyable_and_movable() {};
108
109
110	// Observers
111	virtual bool empty() const = 0;
112	virtual bool full() const = 0;
113	virtual size_type size() const = 0;
114	virtual bool closed() const = 0;
115
116	// Modifiers
117	virtual void close() = 0;
118
119	virtual void push(const value_type& x) = 0;
120
121	virtual void pull(value_type&) = 0;
122	// enable_if is_nothrow_copy_movable<value_type>
123	virtual value_type pull() = 0;
124
125	virtual queue_op_status try_push(const value_type& x) = 0;
126	virtual queue_op_status try_pull(value_type&) = 0;
127
128	virtual queue_op_status nonblocking_push(const value_type& x) = 0;
129	virtual queue_op_status nonblocking_pull(value_type&) = 0;
130
131	virtual queue_op_status wait_push(const value_type& x) = 0;
132	virtual queue_op_status wait_pull(value_type& elem) = 0;
133
134	virtual void push(BOOST_THREAD_RV_REF(value_type) x) = 0;
135	virtual queue_op_status try_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
136	virtual queue_op_status nonblocking_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
137	virtual queue_op_status wait_push(BOOST_THREAD_RV_REF(value_type) x) = 0;
138	};
139
140	template <class T, class ST,
141	#if ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
142	#if defined __GNUC__ && ! defined __clang__
143	#if __GNUC__ < 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ < 5) \|\| !defined(__GXX_EXPERIMENTAL_CXX0X__)
144	bool Copyable = is_copy_constructible<T>::value,
145	bool Movable = true
146	#else
147	bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
148	bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
149	#endif // __GNUC__
150	#elif defined _MSC_VER
151	#if _MSC_VER < 1700
152	bool Copyable = is_copy_constructible<T>::value,
153	bool Movable = true
154	#else
155	bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
156	bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
157	#endif // _MSC_VER
158	#else
159	bool Copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value,
160	bool Movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value
161	#endif
162	#else
163	bool Copyable = is_copy_constructible<T>::value,
164	bool Movable = has_move_emulation_enabled<T>::value
165	#endif
166	>
167	struct queue_base;
168
169	template <class T, class ST>
170	struct queue_base<T, ST, true, true> {
171	typedef queue_base_copyable_and_movable<T, ST> type;
172	};
173	template <class T, class ST>
174	struct queue_base<T, ST, true, false> {
175	typedef queue_base_copyable_only<T, ST> type;
176	};
177	template <class T, class ST>
178	struct queue_base<T, ST, false, true> {
179	typedef queue_base_movable_only<T, ST> type;
180	};
181
182	}
183
184	template <typename ValueType, class SizeType=std::size_t>
185	class queue_base :
186	public detail::queue_base<ValueType, SizeType>::type
187	{
188	public:
189	typedef ValueType value_type;
190	typedef SizeType size_type;
191	// Constructors/Assignment/Destructors
192	virtual ~queue_base() {};
193	};
194
195	}
196	using concurrent::queue_base;
197
198	}
199
200	#include <boost/config/abi_suffix.hpp>
201
202	#endif