diff -r 000000000000 -r 56b72877c1cb hotspotfw/hsserver/inc/algorithm.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/hotspotfw/hsserver/inc/algorithm.h Thu Dec 17 09:20:28 2009 +0200 @@ -0,0 +1,283 @@ +/* +* Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Algorithms for HotSpot FW +* +*/ + + + + + + +#ifndef ALGORITHM_H +#define ALGORITHM_H + +/** +* global operator!= for type T +* @param aLhs left hand side +* @param aRhs right hand side +* @return ETrue equal, EFalse not equal +*/ +template< class T > +inline TBool operator!= ( + const T& aLhs, + const T& aRhs) + { + return !( aLhs == aRhs ); + } + +/** +* global operator > for type T +* @param aLhs left hand side +* @param aRhs right hand side +* @return ETrue greater, EFalse else +*/ +template< class T > +inline TBool operator > ( + const T& aLhs, + const T& aRhs) + { + return ( aRhs < aLhs ); + } + +/** +* global operator <= for type T +* @param aLhs left hand side +* @param aRhs right hand side +* @return ETrue smaller or equal, EFalse else +*/ +template< class T > +inline TBool operator <= ( + const T& aLhs, + const T& aRhs) + { + return !( aRhs < aLhs ); + } + +/** +* global operator >= for type T +* @param aLhs left hand side +* @param aRhs right hand side +* @return ETrue greater or equal, EFalse else +*/ +template< class T > +inline TBool operator >= ( + const T& aLhs, + const T& aRhs) + { + return !( aLhs < aRhs ); + } + +/** +* Just like equal in C++ STL for testing equality for T type +* Checks weather elements in the range [aBeg, aEnd) are equal +* to the elements in the range starting with aCmpBeg +* Complexity: linear +* @param aBeg begin of the search range +* @param aEnd end ( one past last element ) of the search range +* @param aCmpBeg begin of the range to be compared with +* @return ETrue equal, EFalse not equal +*/ +template< class T > +inline TBool equal( + const T* aBeg, + const T*const aEnd, + const T* aCmpBeg) + { + while ( aBeg != aEnd ) + { + if ( *aBeg != *aCmpBeg ) + { + return EFalse; + } + ++aBeg; + ++aCmpBeg; + } + + return ETrue; + } + +/** +* Just like find in C++ STL +* Returns the position of the first element in the range [aBeg, aEnd) +* that has a value equal to aValue +* Complexity: linear +* @param aBeg begin of range +* @param aEnd end ( one past last element ) of the range +* @param aValue value to be searched +* @return the position of the first element in the range (aBeg, aEnd] +* that has a value equal to aValue. aEnd is returned if no matching +* element is found +*/ +template< class T, class J > +inline T* find( + const T* aBeg, + const T* const aEnd, + const J& aValue) + { + while ( aBeg != aEnd ) + { + if ( *aBeg == aValue ) + { + break; + } + + ++aBeg; + } + + return const_cast(aBeg); + } + +/** +* Just like find_if in C++ STL +* Returns the position of the first element in the range [aBeg, aEnd) +* for which the unary predicate op(elem) yields true +* Complexity: linear +* @param aBeg begin of range +* @param aEnd end ( one past last element ) of the range +* @param aUnaryPredicate a unary predicate +* @return the position of the first element in the range (aBeg, aEnd] +* for which the unary predicate op(elem) yields true. +* aEnd is returned if no matching element is found +* NOTE: aUnaryPredicate should not change its state during a function call +*/ +template< class T, class J > +inline T* find_if( + const T* aBeg, + const T* const aEnd, + const J& aUnaryPredicate) + { + while ( aBeg != aEnd ) + { + if ( aUnaryPredicate( *aBeg ) ) + { + break; + } + + ++aBeg; + } + + return const_cast(aBeg); + } + +/** +* Just like fill in C++ STL for T type +* Assigns aValue to each element in the range [aBeg, aEnd) +* The caller must ensure that the destination range is big enough +* Complexity: linear +* @param aBeg begin of range +* @param aEnd end ( one past last element ) of the range +* @param aValue value to be assigned +*/ +template< class T, class J> +inline void fill( + T* aBeg, + const T* const aEnd, + const J& aValue) + { + while ( aBeg != aEnd ) + { + *aBeg = aValue; + ++aBeg; + } + } + +/** +* Just like fill_n in C++ STL for T type +* Assigns aValue to the first aNum elements in the range starting with aBeg +* The caller must ensure that the destination range is big enough +* Complexity: linear +* @param aBeg begin of range +* @param aNum number of elements to be processed +* @param aValue value to be assigned +*/ +template< class T, class J > +inline void fill_n( + T* aBeg, + TUint32 aNum, + const J& aValue) + { + while ( aNum ) + { + *aBeg = aValue; + ++aBeg; + --aNum; + } + } + +/** +* Just like copy in C++ STL +* @param aSrc begin of copy +* @param aSrcEnd end of copy +* @param aDest target of copy +* @return aDest +*/ +template +inline T* copy( + const T* aSrc, + const T* aSrcEnd, + T* aDest) + { + while ( aSrc != aSrcEnd ) + { + *aDest = *aSrc; + ++aSrc; + ++aDest; + } + + return aDest; + } + +template +inline T* reverse_copy( + const T* aSrcBeg, + const T* aSrcEnd, + T* aDest) + { + --aSrcEnd; + while ( aSrcEnd >= aSrcBeg ) + { + *aDest = *aSrcEnd; + --aSrcEnd; + ++aDest; + } + + return aDest; + } + +/** +* Does a looped copy for T type +* @param aSource source of the copy +* @param aDest destination where to copy +* @param aCount number of iterations +* @return aDest +*/ +template +inline TAny* assign( + const T* aSource, + T* aDest, + const TInt aCount) + { + TAny* origdest = static_cast(aDest); + for ( TInt idx = 0 ; idx != aCount ; ++idx, ++aSource, ++aDest ) + { + *aDest = *aSource; + } + + return origdest; + } + +#endif // ALGORITHM_H + +// End of File