queue

C语言库函数的原型,有用的拿去

// queue stl/clr header
#ifndef _CLI_QUEUE_
 #define _CLI_QUEUE_
#include <cliext/algorithm>	// for push/pop heap
#include <cliext/deque>	// for default queue container
#include <cliext/functional>	// for BinaryDelegate
#include <cliext/iterator>
#include <cliext/vector>	// for default priority_queue container

namespace cliext {
	namespace impl {
//
// TEMPLATE CLASS queue_base
//
template<typename _Value_t,
	typename _Cont_t>
	ref class queue_base
	:	public _STLCLR IQueue<_Value_t,
		typename _Container_traits<_Cont_t>::generic_container_handle>
	{	// FIFO queue of elements
public:
	// types
	typedef queue_base<_Value_t, _Cont_t> _Mytype_t;
	typedef _STLCLR IQueue<_Value_t,
		typename _Container_traits<_Cont_t>::generic_container_handle>
		_Mycont_it;
	typedef cli::array<_Value_t> _Myarray_t;

	typedef int size_type;
	typedef int difference_type;
	typedef _Value_t value_type;
	typedef value_type% reference;
	typedef value_type% const_reference;

	typedef _Mycont_it generic_container;
	typedef value_type generic_value;

	typedef typename _Dehandle<_Cont_t>::type container_type;

	// basics
	queue_base()
		:	c(gcnew container_type)
		{	// default constructor
		}

	queue_base% operator=(queue_base% _Right)
		{	// assign
		assign(_Right);
		return (*this);
		}

	operator _Mycont_it^()
		{	// convert to interface
		return (this);
		}

	// constructors
	explicit queue_base(container_type% _Cont)
		:	c(gcnew container_type(_Cont))
		{	// construct from container
		}

	// destructor
	~queue_base()
		{	// destroy the object
		delete c;
		}

	// accessors
	property value_type front_item
		{	// get or set front element
		value_type get()
			{	// get first element
			return (front());
			}

		void set(value_type _Val)
			{	// set first element
			front() = _Val;
			}
		};

	property value_type back_item
		{	// get or set back element
		value_type get()
			{	// get last element
			return (back());
			}

		void set(value_type _Val)
			{	// set last element
			back() = _Val;
			}
		};

	virtual reference front()
		{	// get oldest element
		return (((typename container_type::generic_container^)c)->front());
		}

	virtual reference back()
		{	// get newest element
		return (((typename container_type::generic_container^)c)->back());
		}

	virtual container_type^ get_container()
		{	// return container
		return (c);
		}

	// converters
	virtual System::Object^ Clone()
		{	// clone the queue
		return (gcnew queue_base(*c));
		}

	_Myarray_t^ to_array()
		{	// convert to array
		return (c->to_array());
		}

	// size controllers
	virtual size_type size()
		{	// return length of sequence
		return (c->size());
		}

	virtual bool empty()
		{	// test if sequence is empty
		return (size() == 0);
		}

	// mutators
	virtual void push(value_type _Val)
		{	// insert element at back end
		c->push_back(_Val);
		}

	virtual void pop()
		{	// erase element at front end
		c->pop_front();
		}

	virtual void assign(_Mytype_t% _Right)
		{	// assign
		*c = *_Right.get_container();
		}

_STLCLR_FIELD_ACCESS:
	// data members
	container_type^ c;	// the underlying container

private:
	virtual reference front_virtual() sealed
		= _Mycont_it::front
		{	// get oldest element
		return (front());
		}

	virtual reference back_virtual() sealed
		= _Mycont_it::back
		{	// get newest element
		return (back());
		}

	virtual typename _Container_traits<_Cont_t>::generic_container_handle
		get_container_virtual() sealed
		= _Mycont_it::get_container
		{	// return container
		return (get_container());
		}

	// size controllers
	virtual size_type size_virtual() sealed
		= _Mycont_it::size
		{	// return length of sequence
		return (size());
		}

	virtual bool empty_virtual() sealed
		= _Mycont_it::empty
		{	// test if sequence is empty
		return (empty());
		}

	// mutators
	virtual void push_virtual(value_type _Val) sealed
		= _Mycont_it::push
		{	// insert element at end
		push(_Val);
		}

	virtual void pop_virtual() sealed
		= _Mycont_it::pop
		{	// erase element at end
		pop();
		}

	virtual void assign_virtual(_Mycont_it^ _Right) sealed
		= _Mycont_it::assign
		{	// assign
		assign(*(_Mytype_t^)_Right);
		}
	};

//
// TEMPLATE CLASS queue_select
//
template<typename _Value_t,
	typename _Cont_t,
	bool _Is_ref>
	ref class queue_select
	:	public queue_base<_Value_t, _Cont_t^>
	{	// FIFO queue of elements
public:
	// types
	typedef queue_select<_Value_t, _Cont_t, _Is_ref> _Mytype_t;
	typedef queue_base<_Value_t, _Cont_t^> _Mybase_t;
//	typedef _STLCLR IQueue<_Value_t, _Cont_t> _Mycont_it;
//	typedef cli::array<_Value_t> _Myarray_t;

//	typedef int size_type;
//	typedef int difference_type;
	typedef _Value_t value_type;
	typedef value_type% reference;
	typedef value_type% const_reference;

//	typedef _Mycont_it generic_container;
//	typedef value_type generic_value;

//	typedef _Cont_t container_type;

	// basics
	queue_select()
		{	// construct with empty container
		}

	queue_select% operator=(queue_select% _Right)
		{	// assign
		_Mybase_t::operator=(_Right);
		return (*this);
		}

	// constructors
	explicit queue_select(container_type% _Cont)
		:	_Mybase_t(_Cont)
		{	// construct with specified container
		}
	};

//
// TEMPLATE CLASS queue_select: _Value_t REF SPECIALIZATION
//
template<typename _Value_t,
	typename _Cont_t>
	ref class queue_select<_Value_t, _Cont_t, true>
	:	public queue_base<_Value_t^, _Cont_t^>
	{	// FIFO queue of elements
public:
	// types
	typedef queue_select<_Value_t, _Cont_t, true> _Mytype_t;
	typedef queue_base<_Value_t^, _Cont_t^> _Mybase_t;
//	typedef _STLCLR IQueue<_Value_t, _Cont_t> _Mycont_it;
//	typedef cli::array<_Value_t> _Myarray_t;

//	typedef int size_type;
//	typedef int difference_type;
	typedef _Value_t value_type;
	typedef value_type% reference;
	typedef value_type% const_reference;

//	typedef _Mycont_it generic_container;
//	typedef value_type generic_value;

//	typedef _Cont_t container_type;

	// basics
	queue_select()
		{	// construct with empty container
		}

	queue_select% operator=(queue_select% _Right)
		{	// assign
		_Mybase_t::operator=(_Right);
		return (*this);
		}

	// constructors
	explicit queue_select(container_type% _Cont)
		:	_Mybase_t(_Cont)
		{	// construct with specified container
		}

	// accessors
	property value_type front_item
		{	// get or set front element
		value_type get()
			{	// get last element
			return (front());
			}

		void set(value_type _Val)
			{	// set last element
			front() = _Val;
			}
		};

	property value_type back_item
		{	// get or set back element
		value_type get()
			{	// get last element
			return (back());
			}

		void set(value_type _Val)
			{	// set last element
			back() = _Val;
			}
		};

	virtual reference front() new
		{	// get top element
		return (c->front());
		}

	virtual reference back() new
		{	// get top element
		return (c->back());
		}

	// mutators
	void push(value_type _Val)
		{	// insert element at end
		c->push_back(_Val);
		}
	};
	}	// namespace cliext::impl

//
// TEMPLATE CLASS queue
//
template<typename _Value_t,
	typename _Cont_t = cliext::deque<_Value_t>^>
	ref class queue
	:	public impl::queue_select<
			_Value_t,
			typename _Dehandle<_Cont_t>::type,
			__is_ref_class(typename _Dehandle<_Value_t>::type)
				&& !is_handle<_Value_t>::value>
	{	// FIFO queue of elements
public:
	// types
	typedef queue<_Value_t, _Cont_t> _Mytype_t;
	typedef impl::queue_select<
		_Value_t,
		typename _Dehandle<_Cont_t>::type,
		__is_ref_class(typename _Dehandle<_Value_t>::type)
			&& !is_handle<_Value_t>::value> _Mybase_t;
//	typedef cli::array<_Value_t> _Myarray_t;

//	typedef int size_type;
//	typedef int difference_type;
//	typedef _Value_t value_type;
//	typedef value_type% reference;
//	typedef value_type% const_reference;

//	typedef _Mycont_it generic_container;
//	typedef value_type generic_value;

//	typedef _Cont_t container_type;

	// basics
	queue()
		{	// construct with empty container
		}

	queue(queue% _Right)
		:	_Mybase_t(*_Right.get_container())
		{	// construct by copying a queue
		}

	queue(queue^ _Right)
		:	_Mybase_t(*_Right->get_container())
		{	// construct by copying a queue
		}

	queue% operator=(queue% _Right)
		{	// assign
		_Mybase_t::operator=(_Right);
		return (*this);
		}

	queue% operator=(queue^ _Right)
		{	// assign
		_Mybase_t::operator=(*_Right);
		return (*this);
		}

	// constructors
	explicit queue(container_type% _Cont)
		:	_Mybase_t(_Cont)
		{	// construct with specified container
		}

	// interfaces
	virtual System::Object^ Clone() override
		{	// clone the vector
		return (gcnew _Mytype_t(*this));
		}
	};

//
// TEMPLATE COMPARISONS
//
template<typename _Value_t,
	typename _Cont_t> inline
	bool operator==(queue<_Value_t, _Cont_t>% _Left,
		queue<_Value_t, _Cont_t>% _Right)
	{	// test if _Left == _Right
	return (*_Left.get_container() == *_Right.get_container());
	}

template<typename _Value_t,
	typename _Cont_t> inline
	bool operator!=(queue<_Value_t, _Cont_t>% _Left,
		queue<_Value_t, _Cont_t>% _Right)
	{	// test if _Left != _Right
	return (!(_Left == _Right));
	}

template<typename _Value_t,
	typename _Cont_t> inline
	bool operator<(queue<_Value_t, _Cont_t>% _Left,
		queue<_Value_t, _Cont_t>% _Right)
	{	// test if _Left < _Right
	return (*_Left.get_container() < *_Right.get_container());
	}

template<typename _Value_t,
	typename _Cont_t> inline
	bool operator>=(queue<_Value_t, _Cont_t>% _Left,
		queue<_Value_t, _Cont_t>% _Right)
	{	// test if _Left >= _Right
	return (!(_Left < _Right));
	}

template<typename _Value_t,
	typename _Cont_t> inline
	bool operator>(queue<_Value_t, _Cont_t>% _Left,
		queue<_Value_t, _Cont_t>% _Right)
	{	// test if _Left > _Right
	return (_Right < _Left);
	}

template<typename _Value_t,
	typename _Cont_t> inline
	bool operator<=(queue<_Value_t, _Cont_t>% _Left,