119 lines
		
	
	
		
			3.1 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
		
		
			
		
	
	
			119 lines
		
	
	
		
			3.1 KiB
		
	
	
	
		
			Plaintext
		
	
	
	
	
	
| 
								 | 
							
								//  (C) Copyright Jeremy Siek 2004 
							 | 
						||
| 
								 | 
							
								//  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)
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifndef BOOST_QUEUE_HPP
							 | 
						||
| 
								 | 
							
								#define BOOST_QUEUE_HPP
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#include <deque>
							 | 
						||
| 
								 | 
							
								#include <algorithm>
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								namespace boost {
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, 
							 | 
						||
| 
								 | 
							
								          class _Sequence = std::deque<_Tp> >
							 | 
						||
| 
								 | 
							
								class queue;
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Seq>
							 | 
						||
| 
								 | 
							
								inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Seq>
							 | 
						||
| 
								 | 
							
								inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								class queue {
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
							 | 
						||
| 
								 | 
							
								  template <class _Tp1, class _Seq1>
							 | 
						||
| 
								 | 
							
								  friend bool operator== (const queue<_Tp1, _Seq1>&,
							 | 
						||
| 
								 | 
							
								                          const queue<_Tp1, _Seq1>&);
							 | 
						||
| 
								 | 
							
								  template <class _Tp1, class _Seq1>
							 | 
						||
| 
								 | 
							
								  friend bool operator< (const queue<_Tp1, _Seq1>&,
							 | 
						||
| 
								 | 
							
								                         const queue<_Tp1, _Seq1>&);
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								public:
							 | 
						||
| 
								 | 
							
								  typedef typename _Sequence::value_type      value_type;
							 | 
						||
| 
								 | 
							
								  typedef typename _Sequence::size_type       size_type;
							 | 
						||
| 
								 | 
							
								  typedef          _Sequence                  container_type;
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								  typedef typename _Sequence::reference       reference;
							 | 
						||
| 
								 | 
							
								  typedef typename _Sequence::const_reference const_reference;
							 | 
						||
| 
								 | 
							
								#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
							 | 
						||
| 
								 | 
							
								protected:
							 | 
						||
| 
								 | 
							
								#endif
							 | 
						||
| 
								 | 
							
								  _Sequence c;
							 | 
						||
| 
								 | 
							
								public:
							 | 
						||
| 
								 | 
							
								  queue() : c() {}
							 | 
						||
| 
								 | 
							
								  explicit queue(const _Sequence& __c) : c(__c) {}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								  bool empty() const { return c.empty(); }
							 | 
						||
| 
								 | 
							
								  size_type size() const { return c.size(); }
							 | 
						||
| 
								 | 
							
								  reference front() { return c.front(); }
							 | 
						||
| 
								 | 
							
								  const_reference front() const { return c.front(); }
							 | 
						||
| 
								 | 
							
								  reference top() { return c.front(); }
							 | 
						||
| 
								 | 
							
								  const_reference top() const { return c.front(); }
							 | 
						||
| 
								 | 
							
								  reference back() { return c.back(); }
							 | 
						||
| 
								 | 
							
								  const_reference back() const { return c.back(); }
							 | 
						||
| 
								 | 
							
								  void push(const value_type& __x) { c.push_back(__x); }
							 | 
						||
| 
								 | 
							
								  void pop() { c.pop_front(); }
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								  void swap(queue& other)
							 | 
						||
| 
								 | 
							
								  {
							 | 
						||
| 
								 | 
							
								    using std::swap;
							 | 
						||
| 
								 | 
							
								    swap(c, other.c);
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool 
							 | 
						||
| 
								 | 
							
								operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return __x.c == __y.c;
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool
							 | 
						||
| 
								 | 
							
								operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return __x.c < __y.c;
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool
							 | 
						||
| 
								 | 
							
								operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return !(__x == __y);
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool 
							 | 
						||
| 
								 | 
							
								operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return __y < __x;
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool 
							 | 
						||
| 
								 | 
							
								operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return !(__y < __x);
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								bool 
							 | 
						||
| 
								 | 
							
								operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{
							 | 
						||
| 
								 | 
							
								  return !(__x < __y);
							 | 
						||
| 
								 | 
							
								}
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								template <class _Tp, class _Sequence>
							 | 
						||
| 
								 | 
							
								inline void
							 | 
						||
| 
								 | 
							
								swap(queue<_Tp, _Sequence>& __x, queue<_Tp, _Sequence>& __y)
							 | 
						||
| 
								 | 
							
								{ __x.swap(__y); }
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								} /* namespace boost */
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								#endif /* BOOST_QUEUE_HPP */
							 |