MCL/sf/os/wlan: comparison wlan_bearer/wlanldd/wlan_common/umac

equal deleted inserted replaced

--1:000000000000
+:c40eb8fe8501
+/*
+* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:   Generic operation definitions.
+*
+*/
+/*
+* %version: 11 %
+*/
+#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<T*>(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<T*>(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<class T>
+inline T* copy(
+const T* aSrc,
+const T* aSrcEnd,
+T* aDest)
+{
+while ( aSrc != aSrcEnd )
+{
+*aDest = *aSrc;
+++aSrc;
+++aDest;
+}
+return aDest;
+}
+template<class T>
+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<class T>
+inline TAny* assign(
+const T* aSource,
+T* aDest,
+const TInt aCount)
+{
+TAny* origdest = static_cast<TAny*>(aDest);
+for ( TInt idx = 0 ; idx != aCount ; ++idx, ++aSource, ++aDest )
+{
+*aDest = *aSource;
+}
+return origdest;
+}
+#endif      // ALGORITHM_H