da_algorithm.hpp

#ifndef DA_ALGORITHM_H
#define DA_ALGORITHM_H
 
#include <algorithm>
 
namespace DA
{
template< typename _IT, typename _IT_Index, typename _IT_RES >
void copy_out_of_indexs(_IT input_begin, _IT input_end, _IT_Index index_begin, _IT_Index index_end, _IT_RES output_begin, size_t inputIndexStart = 0)
{
    if (index_begin == index_end) {
        std::copy(input_begin, input_end, output_begin);
        return;
    }
    while (input_begin != input_end) {
        if (inputIndexStart == (size_t)(*index_begin)) {
            ++input_begin;
            ++index_begin;
            ++inputIndexStart;
            if (index_begin == index_end) {
                break;
            }
            continue;
        }
        *output_begin = *input_begin;
        ++output_begin;
        ++inputIndexStart;
        ++input_begin;
    }
    std::copy(input_begin, input_end, output_begin);
}
 
template< typename _IT, typename _IT_Index, typename _IT_RES >
void copy_inner_indexs(_IT input_begin, _IT input_end, _IT_Index index_begin, _IT_Index index_end, _IT_RES output_begin, size_t inputIndexStart = 0)
{
    if (index_begin == index_end) {
        return;
    }
    while (input_begin != input_end) {
        if (inputIndexStart == *index_begin) {
            *output_begin = *input_begin;
            ++output_begin;
            ++index_begin;
            if (index_begin == index_end) {
                return;
            }
        }
        ++inputIndexStart;
        ++input_begin;
    }
}
 
template< typename _IT, typename _IT_Index, typename _IT_RES >
void copy_inner_indexs(_IT input_begin, _IT_Index index_begin, _IT_Index index_end, _IT_RES output_begin)
{
    if (index_begin == index_end) {
        return;
    }
    while (index_begin != index_end) {
        *output_begin = *(input_begin + *index_begin);
        ++output_begin;
        ++index_begin;
    }
}
 
template< typename _IT_Index, typename _IT_Data, typename _IT_OldDataArr, typename _IT_NewDataArr >
void insert_inner_indexs(_IT_Index index_be_insert_begin,
                         _IT_Index index_be_insert_end,
                         _IT_Data data_be_insert_begin,
                         _IT_OldDataArr old_data_begin,
                         _IT_OldDataArr old_data_end,
                         _IT_NewDataArr new_data_begin)
{
    size_t i = 0;
 
    while (old_data_begin != old_data_end) {
        if (i == (size_t)(*index_be_insert_begin)) {
            //说明遇到要插入的索引
            *new_data_begin = *data_be_insert_begin;
            ++i;
            ++index_be_insert_begin;
            ++data_be_insert_begin;
            ++new_data_begin;
        } else {
            *new_data_begin = *old_data_begin;
            ++i;
            ++old_data_begin;
            ++new_data_begin;
        }
    }
    while (index_be_insert_begin != index_be_insert_end) {
        *new_data_begin = *data_be_insert_begin;
        ++index_be_insert_begin;
        ++data_be_insert_begin;
        ++new_data_begin;
    }
}
 
template< typename _IT, typename _IT_Index, typename _IT_RES >
void split_with_indexs(_IT input_begin,
                       _IT input_end,
                       _IT_Index index_begin,
                       _IT_Index index_end,
                       _IT_RES outputInnerIndex_begin,
                       _IT_RES outputOutOfIndex_begin,
                       size_t inputIndexStart = 0)
{
    if (index_begin == index_end) {
        std::copy(input_begin, input_end, outputOutOfIndex_begin);
        return;
    }
    while (input_begin != input_end) {
        if (inputIndexStart == (size_t)(*index_begin)) {
            *outputInnerIndex_begin = *input_begin;
            ++outputInnerIndex_begin;
            ++index_begin;
            if (index_begin == index_end) {
                ++input_begin;
                break;
            }
        } else {
            *outputOutOfIndex_begin = *input_begin;
            ++outputOutOfIndex_begin;
        }
        ++inputIndexStart;
        ++input_begin;
    }
    std::copy(input_begin, input_end, outputOutOfIndex_begin);
}
 
template< class InputIterator1, class InputIterator2, class InputIterator3, class OutputIterator, class ThreeOperation >
OutputIterator transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator3 first3, OutputIterator result_first, ThreeOperation three_op)
{
    while (first1 != last1) {
        *result_first = three_op(*first1, *first2, *first3);  // or: *result=binary_op(*first1,*first2++);
        ++result_first;
        ++first1;
        ++first2;
        ++first3;
    }
    return (result_first);
}
 
template< class InputIterator1, class InputIterator2, class InputIterator3, class InputIterator4, class OutputIterator, class FourOperation >
OutputIterator transform(InputIterator1 first1,
                         InputIterator1 last1,
                         InputIterator2 first2,
                         InputIterator3 first3,
                         InputIterator4 first4,
                         OutputIterator result_first,
                         FourOperation four_op)
{
    while (first1 != last1) {
        *result_first = four_op(*first1, *first2, *first3, *first4);  // or: *result=binary_op(*first1,*first2++);
        ++result_first;
        ++first1;
        ++first2;
        ++first3;
        ++first4;
    }
    return (result_first);
}
 
template< class InputIterator1, class InputIterator2, class InputIterator3, class InputIterator4, class InputIterator5, class OutputIterator, class FiveOperation >
OutputIterator transform(InputIterator1 first1,
                         InputIterator1 last1,
                         InputIterator2 first2,
                         InputIterator3 first3,
                         InputIterator4 first4,
                         InputIterator5 first5,
                         OutputIterator result_first,
                         FiveOperation five_op)
{
    while (first1 != last1) {
        *result_first = five_op(*first1, *first2, *first3, *first4, *first5);  // or: *result=binary_op(*first1,*first2++);
        ++result_first;
        ++first1;
        ++first2;
        ++first3;
        ++first4;
        ++first5;
    }
    return (result_first);
}
 
template< class InputIterator1, class InputIterator2, class InputIterator3, class InputIterator4, class InputIterator5, class InputIterator6, class OutputIterator, class SixOperation >
OutputIterator transform(InputIterator1 first1,
                         InputIterator1 last1,
                         InputIterator2 first2,
                         InputIterator3 first3,
                         InputIterator4 first4,
                         InputIterator5 first5,
                         InputIterator6 first6,
                         OutputIterator result_first,
                         SixOperation six_op)
{
    while (first1 != last1) {
        *result_first = six_op(*first1, *first2, *first3, *first4, *first5, *first6);  // or: *result=binary_op(*first1,*first2++);
        ++result_first;
        ++first1;
        ++first2;
        ++first3;
        ++first4;
        ++first5;
        ++first6;
    }
    return (result_first);
}
}
 
#endif  // DA_ALGORITHM_H