170 lines
4.3 KiB
Plaintext
170 lines
4.3 KiB
Plaintext
// utility standard header
|
|
#pragma once
|
|
#ifndef _UTILITY_
|
|
#define _UTILITY_
|
|
#include <iosfwd>
|
|
|
|
#pragma pack(push,8)
|
|
#pragma warning(push,3)
|
|
|
|
_STD_BEGIN
|
|
// TEMPLATE FUNCTION swap (from <algorithm>)
|
|
template<class _Ty> inline
|
|
void swap(_Ty& _Left, _Ty& _Right)
|
|
{ // exchange values stored at _Left and _Right
|
|
_Ty _Tmp = _Left;
|
|
_Left = _Right, _Right = _Tmp;
|
|
}
|
|
|
|
// TEMPLATE STRUCT pair
|
|
template<class _Ty1,
|
|
class _Ty2> struct pair
|
|
{ // store a pair of values
|
|
typedef pair<_Ty1, _Ty2> _Myt;
|
|
typedef _Ty1 first_type;
|
|
typedef _Ty2 second_type;
|
|
|
|
pair()
|
|
: first(_Ty1()), second(_Ty2())
|
|
{ // construct from defaults
|
|
}
|
|
|
|
pair(const _Ty1& _Val1, const _Ty2& _Val2)
|
|
: first(_Val1), second(_Val2)
|
|
{ // construct from specified values
|
|
}
|
|
|
|
template<class _Other1,
|
|
class _Other2>
|
|
pair(const pair<_Other1, _Other2>& _Right)
|
|
: first(_Right.first), second(_Right.second)
|
|
{ // construct from compatible pair
|
|
}
|
|
|
|
void swap(_Myt& _Right)
|
|
{ // exchange contents with _Right
|
|
std::swap(first, _Right.first);
|
|
std::swap(second, _Right.second);
|
|
}
|
|
|
|
friend void swap(_Myt& _Left, _Myt& _Right)
|
|
{ // swap _Left and _Right deques
|
|
_Left.swap(_Right);
|
|
}
|
|
|
|
_Ty1 first; // the first stored value
|
|
_Ty2 second; // the second stored value
|
|
};
|
|
|
|
// pair TEMPLATE OPERATORS
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator==(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test for pair equality
|
|
return (_Left.first == _Right.first && _Left.second == _Right.second);
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator!=(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test for pair inequality
|
|
return (!(_Left == _Right));
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator<(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test if _Left < _Right for pairs
|
|
return (_Left.first < _Right.first ||
|
|
!(_Right.first < _Left.first) && _Left.second < _Right.second);
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator>(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test if _Left > _Right for pairs
|
|
return (_Right < _Left);
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator<=(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test if _Left <= _Right for pairs
|
|
return (!(_Right < _Left));
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
bool __cdecl operator>=(const pair<_Ty1, _Ty2>& _Left,
|
|
const pair<_Ty1, _Ty2>& _Right)
|
|
{ // test if _Left >= _Right for pairs
|
|
return (!(_Left < _Right));
|
|
}
|
|
|
|
template<class _Ty1,
|
|
class _Ty2> inline
|
|
pair<_Ty1, _Ty2> __cdecl make_pair(_Ty1 _Val1, _Ty2 _Val2)
|
|
{ // return pair composed from arguments
|
|
return (pair<_Ty1, _Ty2>(_Val1, _Val2));
|
|
}
|
|
|
|
// TEMPLATE OPERATORS
|
|
namespace rel_ops
|
|
{ // nested namespace to hide relational operators from std
|
|
template<class _Ty> inline
|
|
bool __cdecl operator!=(const _Ty& _Left, const _Ty& _Right)
|
|
{ // test for inequality, in terms of equality
|
|
return (!(_Left == _Right));
|
|
}
|
|
|
|
template<class _Ty> inline
|
|
bool __cdecl operator>(const _Ty& _Left, const _Ty& _Right)
|
|
{ // test if _Left > _Right, in terms of operator<
|
|
return (_Right < _Left);
|
|
}
|
|
|
|
template<class _Ty> inline
|
|
bool __cdecl operator<=(const _Ty& _Left, const _Ty& _Right)
|
|
{ // test if _Left <= _Right, in terms of operator<
|
|
return (!(_Right < _Left));
|
|
}
|
|
|
|
template<class _Ty> inline
|
|
bool __cdecl operator>=(const _Ty& _Left, const _Ty& _Right)
|
|
{ // test if _Left >= _Right, in terms of operator<
|
|
return (!(_Left < _Right));
|
|
}
|
|
}
|
|
_STD_END
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
|
|
#endif /* _UTILITY_ */
|
|
|
|
/*
|
|
* Copyright (c) 1992-2001 by P.J. Plauger. ALL RIGHTS RESERVED.
|
|
* Consult your license regarding permissions and restrictions.
|
|
*/
|
|
|
|
/*
|
|
* This file is derived from software bearing the following
|
|
* restrictions:
|
|
*
|
|
* Copyright (c) 1994
|
|
* Hewlett-Packard Company
|
|
*
|
|
* Permission to use, copy, modify, distribute and sell this
|
|
* software and its documentation for any purpose is hereby
|
|
* granted without fee, provided that the above copyright notice
|
|
* appear in all copies and that both that copyright notice and
|
|
* this permission notice appear in supporting documentation.
|
|
* Hewlett-Packard Company makes no representations about the
|
|
* suitability of this software for any purpose. It is provided
|
|
* "as is" without express or implied warranty.
|
|
V3.10:0009 */
|