Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

180 lines
3.9 KiB

//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1997
//
// File: algos.h
//
//--------------------------------------------------------------------------
//
// algos.h: additions to <algorithms>
//
#ifndef _ALGOS_H_
#define _ALGOS_H_
#include "mscver.h"
#include <vector>
#include <valarray>
#include <algorithm>
#include <functional>
#include <assert.h>
using namespace std;
////////////////////////////////////////////////////////////////////////////////////
//
// Extensions to (plagarisms from) "algorithm" templates
//
////////////////////////////////////////////////////////////////////////////////////
// Template Function count_set_intersection()
// Return the number of elements in common between two ORDERED sets.
// Elements must support operator<.
//
// Usage: count_set_intersection ( iter_beg_1, iter_end_1, iter_beg_2, iter_end_2 );
//
template<class _II1, class _II2> inline
int count_set_intersection(_II1 _F1, _II1 _L1, _II2 _F2, _II2 _L2)
{
for (int _C=0; _F1 != _L1 && _F2 != _L2; )
{
if (*_F1 < *_F2)
++_F1;
else if (*_F2 < *_F1)
++_F2;
else
++_F1, ++_F2, ++_C;
}
return _C;
}
// Template Function count_set_intersection() with predicate. Same as above;
// a predicate function is used to determine ordering; must behave as
// operator<.
template<class _II1, class _II2, class _Pr> inline
int count_set_intersection(_II1 _F1, _II1 _L1, _II2 _F2, _II2 _L2, _Pr _P)
{
for (int _C=0; _F1 != _L1 && _F2 != _L2; )
{
if (_P(*_F1, *_F2))
++_F1;
else if (_P(*_F2, *_F1))
++_F2;
else
++_F1, ++_F2, ++_C;
}
return _C;
}
// Template function ifind().
// Return the index of an item in a vector or -1 if not found.
template <class _VT, class _T>
int ifind ( const _VT & vt, _T t )
{
_VT::const_iterator vtibeg = vt.begin();
_VT::const_iterator vtiend = vt.end();
_VT::const_iterator vtiter = find( vtibeg, vtiend, t );
return vtiter == vtiend
? -1
: vtiter - vtibeg;
}
// Template function pexchange().
// Exchange contents of a pair of pointers
template<class _T>
void pexchange ( _T * & pta, _T * & ptb )
{
_T * ptt = pta;
pta = ptb;
ptb = ptt;
}
// Template function vswap().
// Swap elements of a vector
template<class _T>
void vswap ( vector<_T> & vt, int ia, int ib )
{
assert( ia < vt.size() );
assert( ib < vt.size() );
if ( ia != ib )
{
_T tt = vt[ia];
vt[ia] = vt[ib];
vt[ib] = tt;
}
}
// Template function appendset().
// Append to vector-based set (add if not present)
template <class _T>
bool appendset ( vector<_T> & vt, _T t )
{
if ( ifind( vt, t ) >= 0 )
return false;
vt.push_back(t);
return true;
}
// Template function vclear().
// Clear a valarray or vector to a single value
template <class _VT, class _T>
_VT & vclear ( _VT & vt, const _T & t )
{
for ( int i = 0; i < vt.size(); )
vt[i++] = t;
return vt;
}
// Template function vdup().
// Duplicate a valarray or vector from one or the other
template <class _VTA, class _VTB>
_VTA & vdup ( _VTA & vta, const _VTB & vtb )
{
vta.resize( vtb.size() );
for ( int i = 0; i < vta.size(); i++ )
vta[i] = vtb[i];
return vta;
}
// Template function vequal()
// Compare valarrays or vectors for equality
template <class _VTA, class _VTB>
bool vequal ( _VTA & vta, const _VTB & vtb )
{
if ( vta.size() != vtb.size() )
return false;
for ( int i = 0; i < vta.size(); i++ )
{
if ( vta[i] != vtb[i] )
return false;
}
return true;
}
// Template function vdimchk()
// Treating the first argument as a subscript vector
// and the second as a vector of dimensions, return true
// if the subscript vector is valid for the space.
template <class _VTA, class _VTB>
bool vdimchk ( const _VTA & vta, const _VTB & vtb )
{
if ( vta.size() != vtb.size() )
return false;
for ( int i = 0; i < vta.size(); i++ )
{
if ( vta[i] >= vtb[i] )
return false;
}
return true;
}
#endif