Click here to Skip to main content
13,148,214 members (52,225 online)
Click here to Skip to main content

Stats

20.3K views
2.1K downloads
20 bookmarked
Posted 23 Aug 2009

Font Enumerator

, 1 Sep 2009
A tool that enumerates all fonts installed on Windows, and shows you the preview so as to help you code conveniently.
FontEnumerator_src.zip
FontEnumerator1.gif
FontEnumerator2.gif
FontEnumerator3.gif
FontEnumerator_demo.zip
FontEnumerator.exe
FontEnumerator
res
FontEnumerator.ico
Youngho.bmp
YTL
///////////////////////////////////////////////////////////////////////////////
//
//  stlHelper.hpp: STL�� �����ϱ� ���� ���ø� ���̺귯��
//
//  Copyright (c) PARK Youngho. All rights reserved.
//
///////////////////////////////////////////////////////////////////////////////


//#include <string>
//#include <iostream>
//#include <memory>
//#include <algorithm>
//#include <utility>

namespace std
{
#ifdef _STRING_
#ifndef _STRING_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#define _STRING_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#ifdef UNICODE
	typedef		wstring		tstring;
#else
	typedef		string		tstring;
#endif	// UNICODE
#endif	// _STRING_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#endif	// _STRING_

#ifdef _IOSTREAM_
#ifndef _IOSTREAM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#define _IOSTREAM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#ifdef UNICODE
	typedef		wistream		tistream;
	typedef		wostream		tostream;
	#define		tcin			wcin
	#define		tcout			wcout
	#define		tcerr			wcerr
	#define		tclog			wclog
#else
	typedef		istream			tistream;
	typedef		ostream			tostream;
	#define		tcin			cin
	#define		tcout			cout
	#define		tcerr			cerr
	#define		tclog			clog
#endif	// UNICODE
	#define init_tcin(x)	std::tcin.imbue(std::locale(x));
	#define	init_tcout(x)	std::tcout.imbue(std::locale(x));
	#define	init_tcerr(x)	std::tcerr.imbue(std::locale(x));
	#define	init_tclog(x)	std::tclog.imbue(std::locale(x));
	#define init_cin(x)		std::cin.imbue(std::locale(x));
	#define	init_cout(x)	std::cout.imbue(std::locale(x));
	#define	init_cerr(x)	std::cerr.imbue(std::locale(x));
	#define	init_clog(x)	std::clog.imbue(std::locale(x));
	#define init_wcin(x)	std::wcin.imbue(std::locale(x));
	#define	init_wcout(x)	std::wcout.imbue(std::locale(x));
	#define	init_wcerr(x)	std::wcerr.imbue(std::locale(x));
	#define	init_wclog(x)	std::wclog.imbue(std::locale(x));
#endif	// _IOSTREAM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#endif	// _IOSTREAM_

#ifdef _IOSFWD_
#ifndef _IOSFWD_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#define _IOSFWD_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#ifdef UNICODE
	typedef		wios			tios;
	typedef		wstreambuf		tsteambuf;
	typedef		wistream		tistream;
	typedef		wostream		tostream;
	typedef		wiostream		tiostream;
	typedef		wstringbuf		tstringbuf;
	typedef		wistringstream	tistringstream;
	typedef		wostringstream	tostringstream;
	typedef		wstringstream	tstringstream;
	typedef		wfilebuf		tfilebuf;
	typedef		wifstream		tifstream;
	typedef		wofstream		tofstream;
	typedef		wfstream		tfstream;
#else
	typedef		ios				tios;
	typedef		streambuf		tsteambuf;
	typedef		istream			tistream;
	typedef		ostream			tostream;
	typedef		iostream		tiostream;
	typedef		stringbuf		tstringbuf;
	typedef		istringstream	tistringstream;
	typedef		ostringstream	tostringstream;
	typedef		stringstream	tstringstream;
	typedef		filebuf			tfilebuf;
	typedef		ifstream		tifstream;
	typedef		ofstream		tofstream;
	typedef		fstream			tfstream;
#endif	// UNICODE
#endif	// _IOSFWD_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#endif	// _IOSFWD_

#ifdef _MEMORY_
#ifndef _MEMORY_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#define _MEMORY_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
template<typename _Ty>
struct auto_ptr_compare
{
	bool operator ==(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) == *_Right);
	}

	bool operator !=(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) != *_Right);
	}

	bool operator >(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) > *_Right);
	}

	bool operator >=(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) >= *_Right);
	}

	bool operator <(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) < *_Right);
	}

	bool operator <=(const _Ty& _Right) const
	{
		return (*((_Ty*) ptr) <= *_Right);
	}
};

template<typename _Ty>
class auto_deep_ptr : public auto_ptr<_Ty>, public auto_ptr_compare<_Ty>
{	// wrap an object pointer to ensure destruction
public:
	explicit auto_deep_ptr(_Ty *_Ptr = 0) _THROW0()
		: auto_ptr<_Ty>(_Ptr), auto_ptr_compare()
	{	// construct from object pointer
	}

	auto_deep_ptr(auto_deep_ptr<_Ty>& _Right) _THROW0()
		: auto_ptr<_Ty>(_Right.release()), auto_ptr_compare()
	{	// construct by assuming pointer from _Right auto_ptr
	}

	auto_deep_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
		: auto_ptr<_Ty>(_Right), auto_ptr_compare()
	{	// construct by assuming pointer from _Right auto_ptr_ref
	}

	template<typename _Other>
	operator auto_deep_ptr<_Other>() _THROW0()
	{	// convert to compatible auto_ptr
		return (auto_deep_ptr<_Other>(*this));
	}

	template<typename _Other>
	auto_deep_ptr<_Ty>& operator=(auto_deep_ptr<_Other>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	template<typename _Other>
	auto_deep_ptr(auto_deep_ptr<_Other>& _Right) _THROW0()
		: auto_ptr<_Ty>(_Right), auto_ptr_compare()
	{	// construct by assuming pointer from _Right
	}

	auto_deep_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	auto_deep_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// assign compatible _Right._Ref (assume pointer)
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}
};

// TEMPLATE CLASS auto_array_ptr
template<typename _Ty>
class auto_array_ptr
{	// wrap an object pointer to ensure destruction
public:
	typedef _Ty element_type;

	explicit auto_array_ptr(_Ty *_Ptr = 0) _THROW0()
		: _Myptr(_Ptr)
	{	// construct from object pointer
	}

	auto_array_ptr(auto_array_ptr<_Ty>& _Right) _THROW0()
		: _Myptr(_Right.release())
	{	// construct by assuming pointer from _Right auto_array_ptr
	}

	auto_array_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// construct by assuming pointer from _Right auto_ptr_ref
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		_Myptr = _Ptr;	// reset this
	}

	template<typename _Other>
	operator auto_array_ptr<_Other>() _THROW0()
	{	// convert to compatible auto_array_ptr
		return (auto_array_ptr<_Other>(*this));
	}

	template<typename _Other>
	operator auto_ptr_ref<_Other>() _THROW0()
	{	// convert to compatible auto_ptr_ref
		_Other *_Cvtptr = _Myptr;	// test implicit conversion
		auto_ptr_ref<_Other> _Ans(_Cvtptr);
		_Myptr = 0;	// pass ownership to auto_ptr_ref
		return (_Ans);
	}

	template<typename _Other>
	auto_array_ptr<_Ty>& operator =(auto_array_ptr<_Other>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	template<typename _Other>
	auto_array_ptr(auto_array_ptr<_Other>& _Right) _THROW0()
		: _Myptr(_Right.release())
	{	// construct by assuming pointer from _Right
	}

	auto_array_ptr<_Ty>& operator =(auto_array_ptr<_Ty>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	auto_array_ptr<_Ty>& operator =(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// assign compatible _Right._Ref (assume pointer)
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}

	~auto_array_ptr()
	{	// destroy the object
		delete[] _Myptr;
	}

	_Ty& operator*() const _THROW0()
	{	// return designated value

 #if _HAS_ITERATOR_DEBUGGING
		if (_Myptr == 0)
			_DEBUG_ERROR("auto_array_ptr not dereferencable");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		__analysis_assume(_Myptr);

		return (*get());
	}

	_Ty& operator [](int idx) _THROW0()
	{
		if (_Myptr == 0)
			_DEBUG_ERROR("auto_array_ptr not dereferencable");
		return (get())[idx];
	}

	_Ty *get() const _THROW0()
	{	// return wrapped pointer
		return (_Myptr);
	}

	_Ty *release() _THROW0()
	{	// return wrapped pointer and give up ownership
		_Ty *_Tmp = _Myptr;
		_Myptr = 0;
		return (_Tmp);
	}

	void reset(_Ty* _Ptr = 0)
	{	// destroy designated object and store new pointer
		if (_Ptr != _Myptr)
			delete[] _Myptr;
		_Myptr = _Ptr;
	}

protected:
	_Ty *_Myptr;	// the wrapped object pointer
};

template<typename _Ty = void>
class auto_c_ptr
{	// wrap an object pointer to ensure destruction
public:
	typedef _Ty element_type;

	explicit auto_c_ptr(_Ty *_Ptr = 0) _THROW0()
		: _Myptr(_Ptr)
	{	// construct from object pointer
	}

	auto_c_ptr(auto_c_ptr<_Ty>& _Right) _THROW0()
		: _Myptr(_Right.release())
	{	// construct by assuming pointer from _Right auto_array_ptr
	}

	auto_c_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// construct by assuming pointer from _Right auto_ptr_ref
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		_Myptr = _Ptr;	// reset this
	}

	template<typename _Other>
	operator auto_c_ptr<_Other>() _THROW0()
	{	// convert to compatible auto_array_ptr
		return (auto_c_ptr<_Other>(*this));
	}

	template<typename _Other>
	operator auto_ptr_ref<_Other>() _THROW0()
	{	// convert to compatible auto_ptr_ref
		_Other *_Cvtptr = _Myptr;	// test implicit conversion
		auto_ptr_ref<_Other> _Ans(_Cvtptr);
		_Myptr = 0;	// pass ownership to auto_ptr_ref
		return (_Ans);
	}

	template<typename _Other>
	auto_c_ptr<_Ty>& operator=(auto_c_ptr<_Other>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	template<typename _Other>
	auto_c_ptr(auto_c_ptr<_Other>& _Right) _THROW0()
		: _Myptr(_Right.release())
	{	// construct by assuming pointer from _Right
	}

	auto_c_ptr<_Ty>& operator=(auto_c_ptr<_Ty>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	auto_c_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// assign compatible _Right._Ref (assume pointer)
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}

	~auto_c_ptr()
	{	// destroy the object
		free(_Myptr);
	}

	_Ty& operator*() const _THROW0()
	{	// return designated value

 #if _HAS_ITERATOR_DEBUGGING
		if (_Myptr == 0)
			_DEBUG_ERROR("auto_c_ptr not dereferencable");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		__analysis_assume(_Myptr);

		return (*get());
	}

	_Ty *operator->() const _THROW0()
	{	// return pointer to class object

 #if _HAS_ITERATOR_DEBUGGING
		if (_Myptr == 0)
			_DEBUG_ERROR("auto_c_ptr not dereferencable");
 #endif /* _HAS_ITERATOR_DEBUGGING */

		return (get());
	}

	_Ty *get() const _THROW0()
	{	// return wrapped pointer
		return (_Myptr);
	}

	_Ty *release() _THROW0()
	{	// return wrapped pointer and give up ownership
		_Ty *_Tmp = _Myptr;
		_Myptr = 0;
		return (_Tmp);
	}

	void reset(_Ty* _Ptr = 0)
	{	// destroy designated object and store new pointer
		if (_Ptr != _Myptr)
			free(_Myptr);
		_Myptr = _Ptr;
	}

protected:
	_Ty *_Myptr;	// the wrapped object pointer
};

template<typename _Ty>
class auto_deep_c_ptr : public auto_c_ptr<_Ty>, public auto_ptr_compare<_Ty>
{	// wrap an object pointer to ensure destruction
public:
	explicit auto_deep_c_ptr(_Ty *_Ptr = 0) _THROW0()
		: auto_c_ptr<_Ty>(_Ptr), auto_ptr_compare()
	{	// construct from object pointer
	}

	auto_deep_c_ptr(auto_deep_c_ptr<_Ty>& _Right) _THROW0()
		: auto_c_ptr<_Ty>(_Right.release()), auto_ptr_compare()
	{	// construct by assuming pointer from _Right auto_ptr
	}

	auto_deep_c_ptr(auto_ptr_ref<_Ty> _Right) _THROW0()
		: auto_c_ptr<_Ty>(_Right), auto_ptr_compare()
	{	// construct by assuming pointer from _Right auto_ptr_ref
	}

	template<typename _Other>
	operator auto_deep_c_ptr<_Other>() _THROW0()
	{	// convert to compatible auto_ptr
		return (auto_deep_c_ptr<_Other>(*this));
	}

	template<typename _Other>
	auto_deep_c_ptr<_Ty>& operator=(auto_deep_c_ptr<_Other>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	template<typename _Other>
	auto_deep_c_ptr(auto_deep_c_ptr<_Other>& _Right) _THROW0()
		: auto_c_ptr<_Ty>(_Right), auto_ptr_compare()
	{	// construct by assuming pointer from _Right
	}

	auto_deep_c_ptr<_Ty>& operator=(auto_ptr<_Ty>& _Right) _THROW0()
	{	// assign compatible _Right (assume pointer)
		reset(_Right.release());
		return (*this);
	}

	auto_deep_c_ptr<_Ty>& operator=(auto_ptr_ref<_Ty> _Right) _THROW0()
	{	// assign compatible _Right._Ref (assume pointer)
		_Ty *_Ptr = _Right._Ref;
		_Right._Ref = 0;	// release old
		reset(_Ptr);	// set new
		return (*this);
	}
};
#endif	// _MEMORY_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#endif	// _MEMORY_

#ifdef _ALGORITHM_
#ifndef _ALGORITHM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#define _ALGORITHM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
template<typename _InIt, typename _Fn1>
inline bool foreach(_InIt _First, _InIt _Last, _Fn1 _Func)
{	// perform function for each element
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Func);
	_CHECKED_BASE_TYPE(_InIt) _ChkFirst(_CHECKED_BASE(_First));
	_CHECKED_BASE_TYPE(_InIt) _ChkLast(_CHECKED_BASE(_Last));
	for (_ChkFirst != _ChkLast; ++_ChkFirst)
		if (!_Func(*_ChkFirst))
			return false;
	return true;
}

template<typename _Ty>
inline bool isInRange(_Ty l, _Ty x, _Ty h)
{
	return (l <= x) && (x <= h);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b)
{
	return (x == a) || (x == b);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c)
{
	return (x == a) || (x == b) || (x == c);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d)
{
	return (x == a) || (x == b) || (x == c) || (x == d);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e, _Ty f)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e) || (x == f);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e, _Ty f, _Ty g)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e) || (x == f) || (x == g);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e, _Ty f, _Ty g, _Ty h)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e) || (x == f) || (x == g)
		|| (x == h);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e, _Ty f, _Ty g, _Ty h, _Ty i)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e) || (x == f) || (x == g)
		|| (x == h) || (x == i);
}

template<typename _Ty>
inline bool isOneOf(_Ty x, _Ty a, _Ty b, _Ty c, _Ty d, _Ty e, _Ty f, _Ty g, _Ty h, _Ty i, _Ty j)
{
	return (x == a) || (x == b) || (x == c) || (x == d) || (x == e) || (x == f) || (x == g)
		|| (x == h) || (x == i) || (x == j);
}

#endif	// _ALGORITHM_STLHELPER_D4459FC7_15A3_4C5E_8CD8_15BF92D97BF3
#endif	//_ALGORITHM_

#ifdef _UTILITY_
#ifndef _UTILITY_3AF5ADF6_4E4A_4ba2_9088_B29760AB69F4
#define _UTILITY_3AF5ADF6_4E4A_4ba2_9088_B29760AB69F4
template<int _N, typename _Ty>
class Multiple
{
	_Ty n[_N];

public:
	Multiple(void)
	{
		memset(n, sizeof n);
	}

	Multiple(_Ty first, ...)
	{
		_Ty m = first;
		va_list marker;
		va_start(marker, first); /* Initialize variable arguments. */

		n[0] = first;
		for (int i = 1; i < _N; i++)
			n[i] = va_arg(marker, _Ty);

		va_end(marker); /* Reset variable arguments. */
	}

	bool operator == (Multiple<_N, _Ty>& right)
	{
		for (int i = 0; i < _N; i++)
		{
			if (n[i] != right.n[i])
				return false;
		}
		return true;
	}

	inline bool operator != (Multiple<_N, _Ty>& right)
	{
		return !(*this == right);
	}

	bool operator > (Multiple<_N, _Ty>& right)
	{
		for (int i = 0; i < _N; i++)
		{
			if (n[i] > right.n[i])
				return true;
			else if (n[i] < right.n[i])
				return false;
		}
		return false;
	}

	inline bool operator < (Multiple<_N, _Ty>& right)
	{
		return (*right > *this);
	}

	inline bool operator >= (Multiple<_N, _Ty>& right)
	{
		return !(*this < right);
	}

	inline bool operator <= (Multiple<_N, _Ty>& right)
	{
		return !(*this > right);
	}
};

template<typename  _Ty1, typename _Ty2, typename _Ty3>
struct triple
{	// store a triple of values
	typedef triple<_Ty1, _Ty2, _Ty3> _Myt;
	typedef _Ty1 first_type;
	typedef _Ty2 second_type;
	typedef _Ty2 third_type;

	_Ty1 first;		// the first stored value
	_Ty2 second;	// the second stored value
	_Ty2 third;		// the third stored value

	triple() : first(_Ty1()), second(_Ty2()), third(_Ty3())
	{	// construct from defaults
	}

	triple(const _Ty1& _Val1, const _Ty2& _Val2, const _Ty3& _Val3)
		: first(_Val1), second(_Val2), third(_Val3)
	{	// construct from specified values
	}

	template<typename _Other1, typename _Other2, typename _Other3>
	triple(const triple<_Other1, _Other2, _Other3>& _Right)
		: first(_Right.first), second(_Right.second), third(_Right.third)
	{	// construct from compatible triple
	}

	void swap(_Myt& _Right)
	{	// exchange contents with _Right
		if (this != &_Right)
		{	// different, worth swapping
			_STD _Swap_adl(first, _Right.first);
			_STD _Swap_adl(second, _Right.second);
			_STD _Swap_adl(third, _Right.third);
		}
	}

	bool operator == (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test for triple equality
		return (this->first == _Right.first)
			&& (this->second == _Right.second)
			&& (this->third == _Right.third);
	}

	inline bool operator != (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test for triple inequality
		return !(*this == _Right);
	}

	bool operator < (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test if _Left < _Right for triples
		if (this->first < _Right.first)
			return true;
		if (this->first > _Right.first)
			return false;
		if (this->second < _Right.second)
			return true;
		if (this->second > _Right.second)
			return false;
		return (this->third < _Right.third);
	}

	inline bool operator > (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test if _Left > _Right for triples
		return _Right < *this;
	}

	inline bool operator <= (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test if _Left <= _Right for triples
		return !(*this > _Right);
	}

	inline bool operator >= (const triple<_Ty1, _Ty2, _Ty3>& _Right)
	{	// test if _Left >= _Right for triples
		return !(*this < _Right);
	}
};

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline void swap(triple<_Ty1, _Ty2, _Ty3>& _Left, triple<_Ty1, _Ty2, _Ty3>& _Right)
{	// swap _Left and _Right triples
	_Left.swap(_Right);
}

template<typename _Ty1, typename _Ty2, typename _Ty3>
inline triple<_Ty1, _Ty2, _Ty3> make_triple(_Ty1 _Val1, _Ty2 _Val2, _Ty3 _Val3)
{	// return pair composed from arguments
	return (triple<_Ty1, _Ty2, _Ty3>(_Val1, _Val2, _Val3));
}

#endif	// _UTILITY_3AF5ADF6_4E4A_4ba2_9088_B29760AB69F4
#endif	//
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

PARK Youngho
Korea (Republic of) Korea (Republic of)
I like programming.

You may also be interested in...

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.170924.2 | Last Updated 2 Sep 2009
Article Copyright 2009 by PARK Youngho
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid