adapter

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

	ref class range_enumerator_base
	:	public System::Collections::IEnumerator
	{	// enumerator for a range
public:
	typedef range_enumerator_base<_Iter_t, _Value_t> _Mytype_t;

	typedef _Value_t value_type;

	range_enumerator_base(_Iter_t _First, _Iter_t _Last)
		:	_Myfirst(_First), _Mylast(_Last), _Is_reset(true)
		{	// construct from iterator pair
		}

	virtual bool MoveNext()
		{	// move to next element and test if done
		if (_Is_reset)
			{	// starting, point to front and clear flag
			_Is_reset = false;
			_Mynext = _Myfirst;
			}
		else if (_Mynext != _Mylast)
			++_Mynext;
		return (_Mynext != _Mylast);
		}

	property System::Object^ Current
		{	// get or set next element
		virtual System::Object^ get()
			{	// get next element
			return (_Getval());
			}

		virtual void set(System::Object^ _Val)
			{	// set next element
			_Setval((value_type)_Val);
			}
		};

	virtual void Reset()
		{	// restart enumerator
		_Is_reset = true;
		}

_STLCLR_FIELD_ACCESS:
	value_type _Getval()
		{	// get next element
		if (_Is_reset || _Mynext == _Mylast)
			throw gcnew System::InvalidOperationException();
		return (*_Mynext);
		}

	void _Setval(value_type _Val)
		{	// set next element
		if (_Is_reset || _Mynext == _Mylast)
			throw gcnew System::InvalidOperationException();
		*_Mynext = _Val;
		}

_STLCLR_FIELD_ACCESS:
	bool _Is_reset;	// true when starting/reset
	_Iter_t _Myfirst;	// initial iterator
	_Iter_t _Mynext;	// current iterator
	_Iter_t _Mylast;	// final iterator
	};

//
// TEMPLATE CLASS range_enumerator
//
template<typename _Iter_t,
	typename _Value_t>
	ref class range_enumerator
	:	public range_enumerator_base<_Iter_t, _Value_t>,
			System::Collections::Generic::IEnumerator<_Value_t>
	{	// enumerator for a range
public:
	typedef range_enumerator<_Iter_t, _Value_t> _Mytype_t;
	typedef range_enumerator_base<_Iter_t, _Value_t> _Mybase_t;

	typedef _Value_t value_type;

	range_enumerator(_Iter_t _First, _Iter_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from container and bias
		}

	~range_enumerator()
		{	// destroy the object
		}

	virtual bool MoveNext() override
		{	// move to next element and test if done
		return (_Mybase_t::MoveNext());
		}

	property value_type Current
		{	// get or set next element
		virtual value_type get() new
			{	// get next element
			return (_Mybase_t::_Getval());
			}

		virtual void set(value_type _Val)
			{	// set next element
			_Mybase_t::_Setval(_Val);
			}
		};

	virtual void Reset() override
		{	// restart enumerator
		_Mybase_t::Reset();
		}
	};

//
// TEMPLATE CLASS range_impl
//
template<typename _Iter_t,
	typename _Value_t,
	bool _Is_ref>
	ref class range_impl
	:	public System::Collections::ICollection,
			System::Collections::IEnumerable
	{	// base class of wrapper for an iterator pair delimited range
public:
	// types
	typedef range_impl<_Iter_t, _Value_t, _Is_ref> _Mytype_t;
	typedef cli::array<_Value_t> _Myarray_t;
	typedef System::Collections::Generic::IEnumerable<_Value_t> _Myenum_it;
	typedef _Cont_make_value<_Value_t, _Is_ref> _Mymake_t;

	typedef typename iterator_traits<_Iter_t>::distance_type size_type;
	typedef _Value_t value_type;

	// basics
	range_impl()
		:	_Myfirst(), _Mylast()
		{	// construct empty range
		}

	range_impl(range_impl% _Right)
		:	_Myfirst(_Right._Myfirst), _Mylast(_Right._Mylast)
		{	// construct by copying _Right
		}

	range_impl% operator=(range_impl% _Right)
		{	// assign
		if ((Object^)this != %_Right)
			{	// worth doing, do it
			_Myfirst = _Right._Myfirst;
			_Mylast = _Right._Mylast;
			}
		return (*this);
		}

	// constructors
	range_impl(_Iter_t _First, _Iter_t _Last)
		:	_Myfirst(_First), _Mylast(_Last)
		{	// construct from iterator pair
		}

	// destructor
	~range_impl()
		{	// destroy the object
		}

_STLCLR_FIELD_ACCESS:
	// data members
	_Iter_t _Myfirst;	// beginning of range
	_Iter_t _Mylast;	// end of range

	// interfaces
public:
	System::Object^ Clone()
		{	// clone the range
		return (gcnew range_impl(this));
		}

private:
	property size_type Count
		{	// element count
		virtual size_type get() sealed
			= System::Collections::ICollection::Count::get
			{	// get element count
			return (distance(_Myfirst, _Mylast));
			}
		};

	property bool IsSynchronized
		{	// synchronized status
		virtual bool get() sealed
			= System::Collections::ICollection::IsSynchronized::get
			{	// test if synchronized
			return (false);
			}
		};

	property System::Object^ SyncRoot
		{	// synchronizer
		virtual System::Object^ get() sealed
			= System::Collections::ICollection::SyncRoot::get
			{	// get synchronizer
			return (this);
			}
		};

	virtual void CopyTo(System::Array^ _Dest_arg, int _First) sealed
		= System::Collections::ICollection::CopyTo
		{	// copy to _Dest_arg, beginning at _First
		cli::array<System::Object^>^ _Dest =
			(cli::array<System::Object ^>^)_Dest_arg;
		int _Idx = 0;

		for (_Iter_t _Next = _Myfirst; _Next != _Mylast; ++_Next, ++_Idx)
			{	// copy front to back
			_Dest[_First + _Idx] = *_Next;
			}
		}

	virtual System::Collections::IEnumerator^ GetEnumerator() sealed
		= System::Collections::IEnumerable::GetEnumerator
		{	// get enumerator for the container
		return (gcnew range_enumerator<_Iter_t, _Value_t>(_Myfirst, _Mylast));
		}
	};

//
// TEMPLATE CLASS range_base
//
template<typename _Iter_t,
	typename _Value_t,
	bool _Is_ref>
	ref class range_base
	:	public range_impl<_Iter_t, _Value_t, _Is_ref>,
			System::Collections::Generic::ICollection<_Value_t>,
			System::Collections::Generic::IEnumerable<_Value_t>
	{	// wrapper for an iterator pair delimited range
public:
	// types
	typedef range_base<_Iter_t, _Value_t, _Is_ref> _Mytype_t;
	typedef range_impl<_Iter_t, _Value_t, _Is_ref> _Mybase_t;

	// basics
	range_base()
		:	_Mybase_t()
		{	// construct empty range
		}

	range_base(range_base% _Right)
		:	_Mybase_t(_Right)
		{	// construct by copying _Right
		}

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

	// constructors
	range_base(_Iter_t _First, _Iter_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from [_First, _Last)
		}

	// interfaces
private:
	property size_type Count_generic
		{	// element count
		virtual size_type get() sealed
			= System::Collections::Generic::ICollection<_Value_t>::Count::get
			{	// get element count
			return (distance(_Myfirst, _Mylast));
			}
		};

	property bool IsReadOnly
		{	// test if read only
		virtual bool get() sealed
			= System::Collections::Generic::ICollection<_Value_t>
				::IsReadOnly::get
			{	// test if read only
			return (true);
			}
		};

	virtual void CopyTo(_Myarray_t^ _Dest, int _First) sealed
		= System::Collections::Generic::ICollection<_Value_t>::CopyTo
		{	// copy to _Dest, beginning at _First
		int _Idx = 0;

		for (_Iter_t _Next = _Myfirst; _Next != _Mylast; ++_Next, ++_Idx)
			{	// copy front to back
			_Dest[_First + _Idx] = *_Next;
			}
		}

	virtual System::Collections::Generic::IEnumerator<_Value_t>^
		GetEnumerator() sealed
		= System::Collections::Generic::IEnumerable<_Value_t>::GetEnumerator
		{	// get enumerator for the container
		return (gcnew range_enumerator<_Iter_t, _Value_t>(_Myfirst, _Mylast));
		}

	// mutators
	virtual void Add(value_type) sealed
		= System::Collections::Generic::ICollection<_Value_t>::Add
		{	// add element with value _Val
		throw gcnew System::InvalidOperationException();
		}

	virtual void Clear() sealed
		= System::Collections::Generic::ICollection<_Value_t>::Clear
		{	// erase all elements
		throw gcnew System::InvalidOperationException();
		}

	virtual bool Contains(value_type _Val) sealed
		= System::Collections::Generic::ICollection<_Value_t>::Contains
		{	// search for element matching value _Val
		for (_Iter_t _Next = _Myfirst; _Next != _Mylast; ++_Next)
			{	// compare for object equality
			value_type _Elem = *_Next;

			if (((System::Object^)_Val)->Equals(
				(System::Object^)_Elem))
				return (true);
			}
		return (false);
		}

	virtual bool Remove(value_type) sealed
		= System::Collections::Generic::ICollection<_Value_t>::Remove
		{	// remove first element matching value _Val
#pragma warning(push)
#pragma warning(disable: 4715)
		throw gcnew System::InvalidOperationException();
#pragma warning(pop)
		}
	};

//
// TEMPLATE CLASS range_select
//
template<typename _Iter_t,
	typename _Value_t,
	bool _Is_ref>
	ref class range_select
	:	public range_base<_Iter_t, _Value_t, _Is_ref>
	{	// iterator pair delimited range
public:
	// types
	typedef _Value_t _Gvalue_t;

	typedef range_select<_Iter_t, _Value_t, _Is_ref> _Mytype_t;
	typedef range_base<_Iter_t, _Gvalue_t, _Is_ref> _Mybase_t;

	// basics
	range_select()
		:	_Mybase_t()
		{	// construct default
		}

	range_select(range_select% _Right)
		:	_Mybase_t(_Right)
		{	// construct by copying a range
		}

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

	// constructors
	range_select(_Iter_t _First, _Iter_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from [_First, _Last)
		}
	};

//
// TEMPLATE CLASS range_select: _Value_t REF SPECIALIZATION
//
template<typename _Iter_t,
	typename _Value_t>
	ref class range_select<_Iter_t, _Value_t, true>
	:	public range_base<_Iter_t, _Value_t^, true>
	{	// iterator pair delimited range
public:
	// types
	typedef _Value_t^ _Gvalue_t;

	typedef range_select<_Iter_t, _Value_t, true> _Mytype_t;
	typedef range_base<_Iter_t, _Gvalue_t, true> _Mybase_t;

	typedef _Value_t value_type;

	// basics
	range_select()
		:	_Mybase_t()
		{	// construct default
		}

	range_select(range_select% _Right)
		:	_Mybase_t(_Right)
		{	// construct by copying a range
		}

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

	// constructors
	range_select(_Iter_t _First, _Iter_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from [_First, _Last)
		}
	};
	}	// namespace cliext::impl

//
// TEMPLATE CLASS range_adapter
//
template<typename _Iter_t>
	ref class range_adapter
	:	public impl::range_select<
			_Iter_t,
			typename iterator_traits<_Iter_t>::value_type,
			__is_ref_class(typename _Dehandle<
					typename iterator_traits<_Iter_t>::value_type>::type)
				&& !is_handle<
					typename iterator_traits<_Iter_t>::value_type>::value>
	{	// wrapper for a pair of iterators
public:
	// types
	typedef range_adapter<_Iter_t> _Mytype_t;
	typedef typename iterator_traits<_Iter_t>::value_type _Value_t;
	typedef impl::range_select<
		_Iter_t,
		_Value_t,
		__is_ref_class(typename _Dehandle<_Value_t>::type)
				&& !is_handle<_Value_t>::value> _Mybase_t;

	// basics
	range_adapter()
		:	_Mybase_t()
		{	// default constructor
		}

	range_adapter(range_adapter% _Right)
		:	_Mybase_t(_Right)
		{	// construct by copying _Right
		}

	range_adapter(range_adapter^ _Right)
		:	_Mybase_t(*_Right)
		{	// construct by copying _Right
		}

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

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

	// constructors
	range_adapter(_Iter_t _First, _Iter_t _Last)
		:	_Mybase_t(_First, _Last)
		{	// construct from [_First, _Last)
		}
	};

//
// TEMPLATE FUNCTION make_collection
//
template<typename _Iter_t> inline
	range_adapter<_Iter_t>^ make_collection(_Iter_t _First, _Iter_t _Last)
	{	// wrap an iterator pair
	return (gcnew range_adapter<_Iter_t>(_First, _Last));
	}
}	// namespace cliext
#endif // _CLI_ADAPTER_

/*
 * Copyright (c) 2004-2007 by Dinkumware, Ltd.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
V5.03:0009 */