|
Collaboration diagram for Transformations:
|
|
Transformations | |
| (void) | + fillFrom:count:value: |
| Assign a given value to a number of elements. | |
| (void) | + fillFrom:to:value: |
| Assign a value to a range of elements. | |
| (void) | + forEachFrom:to:function: |
| Perform an operation on each element in a given range. | |
| (BOOL) | + nextPermutationFrom:to: |
| Turn a range into its next permutation. | |
| (BOOL) | + nextPermutationFrom:to:predicate: |
| Turn a range into its next permutation. | |
| (BOOL) | + prevPermutationFrom:to: |
| Turn a range into its previous permutation. | |
| (BOOL) | + prevPermutationFrom:to:predicate: |
| Turn a range into its previous permutation. | |
| (void) | + randomShuffleFrom:to: |
| Reorder a sequence of elements randomly. | |
| (void) | + randomShuffleFrom:to:randGen: |
| Reorder a sequence of elements randomly. | |
| (OLForwardIterator *) | + removeCopyFrom:to:destination:if: |
| Copy a range while selectively removing elements. | |
| (OLForwardIterator *) | + removeCopyFrom:to:destination:value: |
| Copy a range while selectively removing elements. | |
| (OLForwardIterator *) | + removeFrom:to:if: |
| Remove elements from a range. | |
| (OLForwardIterator *) | + removeFrom:to:value: |
| Remove elements from a range. | |
| (OLForwardIterator *) | + replaceCopyFrom:to:destination:if:newValue: |
| Copy a range while selectively replacing elements. | |
| (OLForwardIterator *) | + replaceCopyFrom:to:destination:oldValue:newValue: |
| Copy a range while selectively replacing elements. | |
| (void) | + replaceFrom:to:if:newValue: |
| Replace values in a range. | |
| (void) | + replaceFrom:to:oldValue:newValue: |
| Replace values in a range. | |
| (OLForwardIterator *) | + reverseCopyFrom:to:destination: |
| Copy a range in reverse order. | |
| (void) | + reverseFrom:to: |
| Reverse the order of a range of elements. | |
| (OLForwardIterator *) | + rotateCopyFrom:middle:to:destination: |
| Copy a range and rotate it in one step. | |
| (OLForwardIterator *) | + rotateFrom:middle:to: |
| Rotate a given range. | |
| (OLForwardIterator *) | + transformFrom:to:destination:function: |
| Transform a range. | |
| (OLForwardIterator *) | + transformFrom:to:withArgsFrom:destination:function: |
| Transform a range. | |
| (OLForwardIterator *) | + uniqueCopyFrom:to:destination: |
| Copy a range while eliminating duplicates. | |
| (OLForwardIterator *) | + uniqueCopyFrom:to:destination:predicate: |
| Copy a range while eliminating duplicates. | |
| (OLForwardIterator *) | + uniqueFrom:to: |
| Remove consecutive elements from a range. | |
| (OLForwardIterator *) | + uniqueFrom:to:predicate: |
| Remove consecutive elements from a range. | |
Swapping | |
| (OLForwardIterator *) | + swapRangesFrom:to:with: |
| Swap elements in two ranges. | |
Ranges can be transformed in a wide variety of ways including selectively removing and replacing, permuting, reversing, and many others.
| + (void) fillFrom: | (OLForwardIterator *) | first | ||
| count: | (unsigned) | num | ||
| value: | (id) | object | ||
Assign a given value to a number of elements.
The operation assigns object to num elements starting at first.
| first | the first element from which to begin assignment | |
| num | the number of times to assign object | |
| object | the value to assign |
| + (void) fillFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| value: | (id) | object | ||
Assign a value to a range of elements.
The value object is assigned to every iterator in the range [first, last).
| first | the first in the range of elements to assign | |
| last | one position beyond the last in the range of elements to assign | |
| object | the value to assign |
| + (void) forEachFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| function: | (id< OLUnaryFunction >) | func | ||
Perform an operation on each element in a given range.
Each element in the range [first, last) is passed as an argument to the function object func.
| first | the first in the range of elements | |
| last | one position beyond the last in the range of elements | |
| func | the function object operating on the elements |
| + (BOOL) nextPermutationFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
Turn a range into its next permutation.
This message simple sends the message nextPermutationFrom:to:predicate: using OLLess as the predicate.
| first | the first in the range of elements | |
| last | one beyond the last in the range of elements |
| + (BOOL) nextPermutationFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
| predicate: | (id< OLBoolBinaryFunction >) | pred | ||
Turn a range into its next permutation.
Each range of elements has a finite number of permutations. Where n is the distance from the first in the range to the last, each range will have n! permutations. The next permutation is computed lexicographically, so if the range is ordered using lexicographicalCompareFrom:to:andFrom:andTo:predicate:, then the result of finding the next permutation will be unambiguous. If there is no next permutation in the order defined by pred, then NO is returned and the sequence is placed in the order of its first permutation in the order defined by pred. If a next permutation is found, then the message returns YES and the sequence is placed in the order of the next permutation as defined by pred.
| first | the first in the range of elements | |
| last | one beyond the last in the range of elements | |
| pred | the predicate used to define the lexicographical order of permutations |
| + (BOOL) prevPermutationFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
Turn a range into its previous permutation.
This message simple sends the message prevPermutationFrom:to:predicate: using OLLess as the predicate.
| first | the first in the range of elements | |
| last | one beyond the last in the range of elements |
| + (BOOL) prevPermutationFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
| predicate: | (id< OLBoolBinaryFunction >) | pred | ||
Turn a range into its previous permutation.
Each range of elements has a finite number of permutations. Where n is the distance from the first in the range to the last, each range will have n! permutations. The previous permutation is computed lexicographically, so if the range is ordered using lexicographicalCompareFrom:to:andFrom:andTo:predicate:, then the result of finding the previous permutation will be unambiguous. If there is no previous permutation in the order defined by pred, then NO is returned and the sequence is placed in the order of its last permutation in the order defined by pred. If a previous permutation is found, then the message returns YES and the sequence is placed in the order of the previous permutation as defined by pred.
| first | the first in the range of elements | |
| last | one beyond the last in the range of elements | |
| pred | the predicate used to define the lexicographical order of permutations |
| + (void) randomShuffleFrom: | (OLRandomAccessIterator *) | first | ||
| to: | (OLRandomAccessIterator *) | last | ||
Reorder a sequence of elements randomly.
The elements in the range [first, last) are placed in a random order. The message uses one of the following functions to generate random numbers:
random() lrand48() rand_s() rand() You must properly seed the random number generator prior to using this algorithm, and you can find out which random number generator is in use by checking for a defined macro from the following list:
OL_HAVE_RANDOM OL_HAVE_LRAND48 OL_HAVE_RAND_S OL_HAVE_RAND
Only one of those will be defined in the file ObjectiveLib/Config.h.
| first | the first in the range to shuffle | |
| last | one beyond the last in the range to shuffle |
| + (void) randomShuffleFrom: | (OLRandomAccessIterator *) | first | ||
| to: | (OLRandomAccessIterator *) | last | ||
| randGen: | (id< OLUnaryFunction >) | gen | ||
Reorder a sequence of elements randomly.
The elements in the range [first, last) are placed in a random order. The random number generator gen is a special kind of function object. The argument to the unary function must respond to the message unsignedIntValue, which will return an integer greater than or equal to zero. The result of the unary function must also respond to the message unsignedIntValue, which will return an integer greater than or equal to zero and less than the value of the unsignedIntValue which is the argument to the unary function.
unsignedIntValue, and must return a result that responds to the message unsignedIntValue.| first | the first in the range to shuffle | |
| last | one beyond the last in the range to shuffle | |
| gen | the random number generator to use |
| + (OLForwardIterator*) removeCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| if: | (id< OLBoolUnaryFunction >) | pred | ||
Copy a range while selectively removing elements.
All elements in the range [first, last) for which the predicate pred does not return YES when passed each element as an argument are copied to the range that begins from dest. An iterator that points to one position beyond the last element copied is returned.
| first | the first in the range to copy | |
| last | one beyond the last in the range to copy | |
| dest | the first in the range to which to copy elements | |
| pred | the predicate that, when passed each element in the range [first, last) as an argument, returns YES for those that should not be copied to dest |
| + (OLForwardIterator*) removeCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| value: | (id) | object | ||
Copy a range while selectively removing elements.
All elements in the range [first, last) for which the message isEqual:, when passed object as an argument, returns NO are copied to the range that begins from dest. An iterator that points to one position beyond the last element copied is returned.
[first, last) must respond to the message isEqual:.| first | the first in the range to copy | |
| last | one beyond the last in the range to copy | |
| dest | the first in the range to which to copy elements | |
| object | the object against which to test each of the elements in the range for equality |
| + (OLForwardIterator*) removeFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| if: | (id< OLBoolUnaryFunction >) | pred | ||
Remove elements from a range.
Naturally, a generic algorithm cannot erase elements from a range. What the message does instead is to organize the range such that for no element in the new range [first, middle) the predicate pred will return YES. The iterator middle is returned by the message after reorganizing the range [first, last). The range from [middle, last) will still contain valid elements, but the exact contents are undefined.
| first | the first in the range from which to remove elements | |
| last | one beyond the last in the range from which to remove elements | |
| pred | the function object that returns YES for each element that should be removed |
| + (OLForwardIterator*) removeFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| value: | (id) | object | ||
Remove elements from a range.
This message is similar to removeFrom:to:if: except that rather than using a function object the message isEqual: is sent to each element in the range [first, last) with object as the argument. If the message returns YES, then the element will not appear in the resulting range [first, middle) where middle points to one position beyond the last element not equal to object. The elements in the range [middle, last) are still valid, but the contents are undefined. The iterator middle is returned.
[first, last) must respond to the message isEqual:.| first | the first in the range from which to remove elements | |
| last | one beyond the last in the range from which to remove elements | |
| object | the object that should be removed from the range [first, last) |
| + (OLForwardIterator*) replaceCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| if: | (id< OLBoolUnaryFunction >) | pred | ||
| newValue: | (id) | newv | ||
Copy a range while selectively replacing elements.
All elements from the range [first, last) are copied to the range that begins at dest, but those elements for which the predicate pred returns YES are replaced in the destination range with the value newv. An iterator that points to one position beyond the last element copied is returned.
| first | the first in the range from which to copy elements | |
| last | one beyond the last in the range from which to copy elements | |
| dest | the first in the range to which to copy elements | |
| pred | the predicate that, when passed each element in the range [first, last) as an argument, returns YES for those that should be replaced by newv | |
| newv | the value used to replace values in the destination range |
| + (OLForwardIterator*) replaceCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| oldValue: | (id) | oldv | ||
| newValue: | (id) | newv | ||
Copy a range while selectively replacing elements.
All elements from the range [first, last) are copied to the range that begins at dest, but those elements for which the message isEqual: returns YES when passed oldv as an argument are replaced with the value newv. An iterator that points to one position beyond the last element copied is returned.
[first, last) must respond to the message isEqual:.| first | the first in the range from which to copy elements | |
| last | one beyond the last in the range from which to copy elements | |
| dest | the first in the range to which to copy elements | |
| oldv | the value that should be replaced with newv in the destination range | |
| newv | the value used to replace values in the destination range |
| + (void) replaceFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| if: | (id< OLBoolUnaryFunction >) | pred | ||
| newValue: | (id) | newv | ||
Replace values in a range.
Each element in the range [first, last) is tested using the predicate pred, and for each case where YES is returned that value is replaced with the value newv.
| first | the first in the range to check for replacements | |
| last | one beyond the last in the range to check for replacements | |
| pred | the function object used to test each element in the range | |
| newv | the value with which to replace the candidate values |
| + (void) replaceFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| oldValue: | (id) | oldv | ||
| newValue: | (id) | newv | ||
Replace values in a range.
Each element in the range [first, last) is sent the message isEqual: using oldv as an argument. For each case where isEqual: returns YES the value is replaced with the value of newv.
[first, last) must respond to the message isEqual:.| first | the first in the range to check for replacements | |
| last | one beyond the last in the range to check for replacements | |
| oldv | the value with which to compare the values in the range | |
| newv | the value with which to replace the candidate values |
| + (OLForwardIterator*) reverseCopyFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
Copy a range in reverse order.
The elements in the range [first, last) are copied to the range starting at dest in reverse order. An iterator pointing to one position beyond the last element copied in the destination range is returned.
| first | the first in the range from which to copy elements | |
| last | one beyond the last in the range from which to copy elements | |
| dest | the first element in the range to which to copy elements |
| + (void) reverseFrom: | (OLBidirectionalIterator *) | first | ||
| to: | (OLBidirectionalIterator *) | last | ||
Reverse the order of a range of elements.
The range [first, last) is placed in reverse order.
| first | the first in the range to reverse | |
| last | one beyond the last in the range to reverse |
| + (OLForwardIterator*) rotateCopyFrom: | (OLForwardIterator *) | first | ||
| middle: | (OLForwardIterator *) | mid | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
Copy a range and rotate it in one step.
Rotation in this context is roughly equivilent to the idea of "left shifting". As it is copied the range is shifted to the left by the distance between first and mid. The value of mid is copied to the position of first, mid plus one is copied to first plus one, and so on. The existing values at first and the values that follow it are copied to mid, and so on. Another way of thinking of it is that the two ranges [first, mid) and [mid, last) are swapped. An iterator pointing to one position beyond the last element copied to the destination range is returned.
| first | the first element in the range from which to copy | |
| mid | the position at which to perform the pivot of rotation in the range from which to copy | |
| last | one beyond the last element in the range from which to copy | |
| dest | the first in the destination range to which to copy |
| + (OLForwardIterator*) rotateFrom: | (OLForwardIterator *) | first | ||
| middle: | (OLForwardIterator *) | mid | ||
| to: | (OLForwardIterator *) | last | ||
Rotate a given range.
Rotation in this context is roughly equivilent to the idea of "left shifting". The range is shifted to the left by the distance between first and mid. The value of mid is copied to the position of first, mid plus one is copied to first plus one, and so on. The existing values at first and the values that follow it are copied to mid, and so on. Another way of thinking of it is that the two ranges [first, mid) and [mid, last) are swapped. An iterator pointing to the new position of the element originally pointed to by mid is returned. In other words the returned iterator is equal to the position of first plus the distance between mid and last.
| first | the first element in the range from which to copy | |
| mid | the position at which to perform the pivot of rotation in the range from which to copy | |
| last | one beyond the last element in the range from which to copy |
| + (OLForwardIterator*) swapRangesFrom: | (OLForwardIterator *) | first1 | ||
| to: | (OLForwardIterator *) | last1 | ||
| with: | (OLForwardIterator *) | first2 | ||
Swap elements in two ranges.
All elements in the range [first1, last1) are assigned to the corresponding element in the range starting at first2 and vice versa. An iterator is returned pointing to one position beyond the last element swapped in the range starting from first2.
[first1, last1).| first1 | the first in the first range to swap | |
| last1 | one beyond the last in the first range to swap | |
| first2 | the first in the second range to swap |
| + (OLForwardIterator*) transformFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| function: | (id< OLUnaryFunction >) | func | ||
Transform a range.
The message performs the unary function func on each element in the range [first, last) and copies the result to the range that begins from dest. Each element is passed as the argument to the unary function's performUnaryFunctionWithArg: message, which presumably will do something to the argument and return another object as the result. An iterator is returned that points to one position beyond the last element copied to the destination range.
| first | the first element in the range to transform | |
| last | one beyond the last element in the range to transform | |
| dest | the first element in the range to which to copy the results of the transformation | |
| func | the function object used to transform the range |
| + (OLForwardIterator*) transformFrom: | (OLForwardIterator *) | first1 | ||
| to: | (OLForwardIterator *) | last | ||
| withArgsFrom: | (OLForwardIterator *) | first2 | ||
| destination: | (OLForwardIterator *) | dest | ||
| function: | (id< OLBinaryFunction >) | func | ||
Transform a range.
This message is very similar to transformFrom:to:destination:function: except that another argument to the function object, which is now a binary function, is plucked from the range starting from first2 and passed as the second argument to func. As with transformFrom:to:destination:function:, each element in the range [first1, last) is passed to func as the first argument to the performBinaryFunctionWithArg:andArg: message. An iterator is returned that points to one position beyond the last element copied to the destination range.
| first1 | the first element in the range to transform | |
| last | one beyond the last element in the range to transform | |
| first2 | the first in the range of elements to use as second arguments to func | |
| dest | the first element in the range to which to copy the results of the transformation | |
| func | the function object used to transform the range |
| + (OLForwardIterator*) uniqueCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
Copy a range while eliminating duplicates.
This message simple sends the message uniqueCopyFrom:to:destination:predicate: using OLEqualTo as the predicate.
| first | the first in the range to copy | |
| last | one beyond the last in the range to copy | |
| dest | the first in the range to which to copy |
| + (OLForwardIterator*) uniqueCopyFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| destination: | (OLForwardIterator *) | dest | ||
| predicate: | (id< OLBoolBinaryFunction >) | pred | ||
Copy a range while eliminating duplicates.
Elements from the range [first, last) are copied to the range starting at dest, except that where there is a series of consecutive elements for which the predicate pred returns YES, only the first is copied. An iterator is returned that points to one position beyond the last element copied to the destination range.
| first | the first in the range to copy | |
| last | one beyond the last in the range to copy | |
| dest | the first in the range to which to copy | |
| pred | the function object used to test for consecutive elements |
| + (OLForwardIterator*) uniqueFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
Remove consecutive elements from a range.
This message simply sends the message uniqueFrom:to:predicate: using OLEqualTo as the predicate.
| first | the first in the range to transform | |
| last | one beyond the last in the range to transform |
| + (OLForwardIterator*) uniqueFrom: | (OLForwardIterator *) | first | ||
| to: | (OLForwardIterator *) | last | ||
| predicate: | (id< OLBoolBinaryFunction >) | pred | ||
Remove consecutive elements from a range.
The message returns an iterator end that is in the range [first, last), and all elements in the range [first, end) will be unique. Uniqueness is tested using the predicate pred, and for any two consecutive elements which for which the predicate returns YES, only the first will appear in the resulting range [first, end). The elements that remain in the range [end, last) will be valid, but the contents are undefined.
| first | the first in the range to transform | |
| last | one beyond the last in the range to transform | |
| pred | the function object used to test elements for equality |
|
