diff options
Diffstat (limited to 'src/include/algorithm')
-rw-r--r-- | src/include/algorithm | 140 |
1 files changed, 140 insertions, 0 deletions
diff --git a/src/include/algorithm b/src/include/algorithm index 9641a797a..cc3886ff5 100644 --- a/src/include/algorithm +++ b/src/include/algorithm @@ -78,6 +78,38 @@ namespace std } /** + * Swaps the values of the elements the given iterators are pointing to. + * @param[in] a iterator to the elements to swap + * @param[in] b iterator to the elements to swap + */ + template<class ForwardIterator1, class ForwardIterator2> + inline void iter_swap(ForwardIterator1 a, ForwardIterator2 b) + { + swap(*a, *b); + } + + /** + * Swaps the values of the elements the given iterators are pointing to. + * @param[in] first1 iterator of the beginning of first range + * @param[in] last1 iterator of the end of first range + * @param[in] first2 iterator of the beginning of the second range + * @return Iterator to the element past the last element exchanged in the + * range beginning with first2. + */ + + template< class ForwardIterator1, class ForwardIterator2 > + inline ForwardIterator2 swap_ranges(ForwardIterator1 first1, + ForwardIterator1 last1, + ForwardIterator2 first2) + { + while (first1 != last1) + { + iter_swap(first1++, first2++); + } + return first2; + } + + /** * Exchange values of two objects * @param[in] a reference to an object to be swaped with b * @param[in] b reference to an object to be swaped with a @@ -87,12 +119,24 @@ namespace std inline void swap(T& a, T&b ) { + // @TODO RTC:162287 use std::move() T c(a); a=b; b=c; } /** + * Swaps the arrays a and b. In effect calls std::swap_ranges(a, a+N, b) + * @param[in] a reference to an object to be swaped with b + * @param[in] b reference to an object to be swaped with a + */ + template< class T, size_t N> + inline void swap(T(&a)[N], T(&b)[N]) + { + swap_ranges(a, a+N, b); + } + + /** * Fill a range with value * @param[in] first ForwardIterator to the first position in the source range. * @param[in] last ForwardIterator to the last position +1 in the source range. @@ -874,7 +918,103 @@ namespace std return result; } + /** Returns true if the range [first1, last1) is equal to the range + * [first2, first2 + (last1 - first1)), and false otherwise + * + * The two ranges are considered equal if, for every iterator i in the range + * [first1,last1), *i equals *(first2 + (i - first1)). The overloads use + * operator== to determine if two elements are equal. + * + * @param[in] first1 - The beginning of the first range. + * @param[in] last1 - The end of the first range. + * @param[in] first2 - The beginning of the second range. + * @return - Returns true equal, false otherwise + */ + template < typename InputIterator1, typename InputIterator2 > + bool equal(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2) + { + while(first1 != last1) + { + if (!(*first1 == *first2)) + { + return false; + } + ++first1; ++first2; + } + return true; + } + /** Returns true if the range [first1, last1) is equal, using a predicate, + * to the range [first2, first2 + (last1 - first1)), and false otherwise + * + * The two ranges are considered equal if, for every iterator i in the range + * [first1,last1), *i equals *(first2 + (i - first1)). The overloads use + * operator== to determine if two elements are equal. + * + * @param[in] first1 - The beginning of the first range. + * @param[in] last1 - The end of the first range. + * @param[in] first2 - The beginning of the second range. + * @param[in] comp - Binary predicate which returns true if the elements + * should be treated as equal. + * @return - Returns true equal, false otherwise + */ + template < typename InputIterator1, typename InputIterator2, + typename BinaryPredicate > + bool equal( InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, BinaryPredicate comp ) + { + while(first1 != last1) + { + if (!comp(*first1, *first2)) + { + return false; + } + ++first1; ++first2; + } + return true; + } + + /** Checks if the first range [first1, last1) is lexicographically less than + * the second range [first2, last2). + * + * Elements are compared using operator<. + * Lexicographical comparison is a operation with the following properties: + * - Two ranges are compared element by element. + * - The first mismatching element defines which range is lexicographically + * less or greater than the other. + * - If one range is a prefix of another, the shorter range is + * lexicographically less than the other. + * - If two ranges have equivalent elements and are of the same length, + * then the ranges are lexicographically equal. + * - An empty range is lexicographically less than any non-empty range. + * - Two empty ranges are lexicographically equal. + * + * @param[in] first1 - The beginning of the first range. + * @param[in] last1 - The end of the first range. + * @param[in] first2 - The beginning of the second range. + * @param[in] last2 - The end of the second range. + * @return - true if the first range is lexicographically less than the + * second. + */ + template < typename InputIterator1, typename InputIterator2 > + bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2) + { + while( (first1 != last1) && (first2 != last2) ) + { + if (*first1 < *first2) + { + return true; + } + if (*first2 < *first1) + { + return false; + } + first1++; first2++; + } + return (first1 == last1) && (first2 != last2); + } }; #endif |