1		// utility standard header
2		#pragma once
3		#ifndef _UTILITY_
4		#define _UTILITY_
5		#ifndef RC_INVOKED
6		#include <iosfwd>
7
8		#ifdef _MSC_VER
9		#pragma pack(push,_CRT_PACKING)
10		#pragma warning(push,3)
11		#endif  /* _MSC_VER */
12
13		_STD_BEGIN
14		// TEMPLATE FUNCTION swap (from <algorithm>)
15		template<class _Ty> inline
16		void swap(_Ty& _Left, _Ty& _Right)
17		{    // exchange values stored at _Left and _Right
18		if (&_Left != &_Right)
19		{    // different, worth swapping
20		_Ty _Tmp = _Left;
21
22		_Left = _Right;
23		_Right = _Tmp;
24		}
25		}
26
27		// TEMPLATE FUNCTION _Swap_adl
28		template<class _Ty> inline
29		void _Swap_adl(_Ty& _Left, _Ty& _Right)
30		{    // exchange values stored at _Left and _Right, using ADL
31		swap(_Left, _Right);
32		}
33
34		// TEMPLATE STRUCT pair
35		template<class _Ty1,
36		class _Ty2>
37		struct pair
38		{    // store a pair of values
39		typedef pair<_Ty1, _Ty2> _Myt;
40		typedef _Ty1 first_type;
41		typedef _Ty2 second_type;
42
43		pair()
44		: first(_Ty1()), second(_Ty2())
45		{    // construct from defaults
46		}
47
48		pair(const _Ty1& _Val1, const _Ty2& _Val2)
49		: first(_Val1), second(_Val2)
50		{    // construct from specified values
51		}
52
53		template<class _Other1,
54		class _Other2>
55		pair(const pair<_Other1, _Other2>& _Right)
56		: first(_Right.first), second(_Right.second)
57		{    // construct from compatible pair
58		}
59
60		void swap(_Myt& _Right)
61		{    // exchange contents with _Right
62		if (this != &_Right)
63		{    // different, worth swapping
64		_STD _Swap_adl(first, _Right.first);
65		_STD _Swap_adl(second, _Right.second);
66		}
67		}
68
69		_Ty1 first;    // the first stored value
70		_Ty2 second;    // the second stored value
71		};
72
73		// pair TEMPLATE FUNCTIONS
74		template<class _Ty1,
75		class _Ty2> inline
76		void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right)
77		{    // swap _Left and _Right pairs
78		_Left.swap(_Right);
79		}
80
81		template<class _Ty1,

Lines 82 ... 91 are skipped.

92		const pair<_Ty1, _Ty2>& _Right)
93		{    // test for pair inequality
94		return (!(_Left == _Right));
95		}
96
97		template<class _Ty1,
98		class _Ty2> inline
99		bool operator<(const pair<_Ty1, _Ty2>& _Left,
100		const pair<_Ty1, _Ty2>& _Right)
101		{    // test if _Left < _Right for pairs
102		return (_Left.first < _Right.first ||
103		!(_Right.first < _Left.first) && _Left.second < _Right.second);
104		}
105
106		template<class _Ty1,
107		class _Ty2> inline
108		bool operator>(const pair<_Ty1, _Ty2>& _Left,
109		const pair<_Ty1, _Ty2>& _Right)
110		{    // test if _Left > _Right for pairs
111		return (_Right < _Left);
112		}
113
114		template<class _Ty1,
115		class _Ty2> inline
116		bool operator<=(const pair<_Ty1, _Ty2>& _Left,
117		const pair<_Ty1, _Ty2>& _Right)
118		{    // test if _Left <= _Right for pairs
119		return (!(_Right < _Left));
120		}
121
122		template<class _Ty1,
123		class _Ty2> inline
124		bool operator>=(const pair<_Ty1, _Ty2>& _Left,
125		const pair<_Ty1, _Ty2>& _Right)
126		{    // test if _Left >= _Right for pairs
127		return (!(_Left < _Right));
128		}
129
130		template<class _Ty1,
131		class _Ty2> inline
132		pair<_Ty1, _Ty2> make_pair(_Ty1 _Val1, _Ty2 _Val2)
133		{    // return pair composed from arguments
134		return (pair<_Ty1, _Ty2>(_Val1, _Val2));
135		}
136
137		// TEMPLATE OPERATORS
138		namespace rel_ops
139		{    // nested namespace to hide relational operators from std
140		template<class _Ty> inline
141		bool  operator!=(const _Ty& _Left, const _Ty& _Right)
142		{    // test for inequality, in terms of equality
143		return (!(_Left == _Right));
144		}
145
146		template<class _Ty> inline
147		bool operator>(const _Ty& _Left, const _Ty& _Right)
148		{    // test if _Left > _Right, in terms of operator<
149		return (_Right < _Left);
150		}
151
152		template<class _Ty> inline
153		bool operator<=(const _Ty& _Left, const _Ty& _Right)
154		{    // test if _Left <= _Right, in terms of operator<
155		return (!(_Right < _Left));
156		}
157
158		template<class _Ty> inline
159		bool operator>=(const _Ty& _Left, const _Ty& _Right)
160		{    // test if _Left >= _Right, in terms of operator<
161		return (!(_Left < _Right));
162		}
163		}
164		_STD_END
165
166		#if _HAS_TR1
167		_STD_BEGIN
168		namespace tr1 {    // TR1 additions
169
170		// TUPLE INTERFACE TO std::tr1::pair
171		template<class _Tuple>
172		struct tuple_size;
173		template<int _Idx,
174		class _Tuple>
175		struct tuple_element;
176		template<class _Ty1,
177		class _Ty2>
178		struct tuple_size<std::pair<_Ty1, _Ty2> >
179		{    // struct to determine number of elements in pair
180		static const int value = 2;
181		};
182
183		template<int _Idx,
184		class _Ty>
185		struct _Pair_data;
186		template<class _Ty1,
187		class _Ty2>
188		struct _Pair_data<0, std::pair<_Ty1, _Ty2> >
189		{    // struct to pick out argument type and value at index 0
190		typedef _Ty1& _Type;
191		typedef const _Ty1& _CType;
192
193		static _Type _Val(std::pair<_Ty1, _Ty2>& _Pr)
194		{    // return value
195		return (_Pr.first);
196		}
197
198		static _CType _Val(const std::pair<_Ty1, _Ty2>& _Pr)
199		{    // return value
200		return (_Pr.first);
201		}
202		};
203
204		template<class _Ty1,
205		class _Ty2>
206		struct _Pair_data<1, std::pair<_Ty1, _Ty2> >
207		{    // struct to pick out argument type and value at index 1
208		typedef _Ty2& _Type;
209		typedef const _Ty2& _CType;
210
211		static _Type _Val(std::pair<_Ty1, _Ty2>& _Pr)
212		{    // return value
213		return (_Pr.second);
214		}
215
216		static _CType _Val(const std::pair<_Ty1, _Ty2>& _Pr)
217		{    // return value
218		return (_Pr.second);
219		}
220		};
221
222		template<class _Ty1,
223		class _Ty2>
224		struct tuple_element<0, std::pair<_Ty1, _Ty2> >
225		{    // struct to determine type of element 0 in pair
226		typedef _Ty1 type;
227		};
228
229		template<class _Ty1,
230		class _Ty2>
231		struct tuple_element<1, std::pair<_Ty1, _Ty2> >
232		{    // struct to determine type of element 1 in pair
233		typedef _Ty2 type;
234		};
235
236		template<int _Idx,
237		class _Ty1,
238		class _Ty2>
239		typename _Pair_data<_Idx, std::pair<_Ty1, _Ty2> >::_Type
240		get(std::pair<_Ty1, _Ty2>& _Pr)
241		{    // return element at _Idx in pair _Pr
242		return (_Pair_data<_Idx, std::pair<_Ty1, _Ty2> >::_Val(_Pr));
243		}
244
245		template<int _Idx,
246		class _Ty1,
247		class _Ty2>
248		typename _Pair_data<_Idx, std::pair<_Ty1, _Ty2> >::_CType
249		get(const std::pair<_Ty1, _Ty2>& _Pr)
250		{    // return element at _Idx in pair _Pr
251		return (_Pair_data<_Idx, std::pair<_Ty1, _Ty2> >::_Val(_Pr));
252		}
253
254		}    // namespace tr1
255		_STD_END
256		#endif /* _HAS_TR1 */
257
258		#ifdef _MSC_VER
259		#pragma warning(pop)
260		#pragma pack(pop)
261		#endif  /* _MSC_VER */
262
263		#endif /* RC_INVOKED */
264		#endif /* _UTILITY_ */
265
266
267		/*
268		* This file is derived from software bearing the following
269		* restrictions:
270		*
271		* Copyright (c) 1994
272		* Hewlett-Packard Company
273		*
274		* Permission to use, copy, modify, distribute and sell this
275		* software and its documentation for any purpose is hereby
276		* granted without fee, provided that the above copyright notice
277		* appear in all copies and that both that copyright notice and
278		* this permission notice appear in supporting documentation.
279		* Hewlett-Packard Company makes no representations about the
280		* suitability of this software for any purpose. It is provided
281		* "as is" without express or implied warranty.
282		*/
283
284		/*
285		* Copyright (c) 1992-2008 by P.J. Plauger.  ALL RIGHTS RESERVED.
286		* Consult your license regarding permissions and restrictions.
287		V5.05:0009 */
288
289
290