ContainerFunctions.hpp

Go to the documentation of this file.

// ========================================================================================
//  ApproxMVBB
//  Copyright (C) 2014 by Gabriel Nützi <nuetzig (at) imes (d0t) mavt (d0t) ethz (døt) ch>
//
//  This Source Code Form is subject to the terms of the Mozilla Public
//  License, v. 2.0. If a copy of the MPL was not distributed with this
//  file, You can obtain one at http://mozilla.org/MPL/2.0/.
// ========================================================================================

#ifndef ApproxMVBB_ContainerFunctions_hpp
#define ApproxMVBB_ContainerFunctions_hpp

namespace ApproxMVBB{
namespace ContainerFunctions {

template<typename Iterator, typename Func>
Iterator moveElementsToFrontIf(Iterator b, Iterator  e, Func f) {

    Iterator w = b;  // write pointer
    while  ( b != e ) {
        if( !f(*b) ) { // if not move to front increment read pointer
            b++;
            continue;
        }

        if(w!=b) {   // copy only if not at same position!
            *w = *b; // copy  value to front (test is not true)
        }
        ++w;
        ++b;
    }
    return w;
}

template<typename Iterator,typename Func>
Iterator moveElementsToBackIf(Iterator b, Iterator  e, Func f) {

    if( b == e  ) {
        return b;
    }
    while(b != e){

        if(f(*b)){
            // Move end to next swappable item
            while(f(*e)){
                --e;
                if( e == b){
                    return e;
                };
            }

            // swap with back
            if(b!=e){
                std::swap(*b,*e);
            }
        }
        ++b;
    }
    return f(*e)? e : ++e;
}


template<typename Iterator, typename Comp>
Iterator moveConsecutiveToFrontIf(Iterator b, Iterator  e, Comp c) {


    if( std::distance(b,e)<2 ) {
        return e;
    }

    Iterator comp = b;
    Iterator write = ++b;
    while  ( b != e ) {
        if( !c(*comp, *b ) ) { // if we can skip element or if
            ++b;
            continue;
        }

        if(write!=b) {   // copy only if not at same position!
            *write = *b; // copy  value to front (test is not true)
        }
        //std::cout << *dest << std::endl;
        comp = write++;
        ++b;
    }

    return write;
}
template<typename Iterator, typename Func, typename Skip>
Iterator moveConsecutiveToFrontIf(Iterator b, Iterator  e, Func f, Skip s) {


    if( std::distance(b,e)<2 ) {
        return e;
    }
    Iterator comp;
    Iterator write = b;
    // skip all at beginning
        while(b!=e && s(*b)){
                ++b;
        }
        if(b!=e){
                // write first element to front
                if(write!=b){
                        *write = *b;
                }
                comp = write++; // shift write pointer (comp is previous)

        // Start loop over all elements
            while  ( b != e ) {
                if(s(*b) || !f(*comp, *b ) ) {
                    ++b;
                    continue;
                }

                if(write!=b) {   // copy only if not at same position!
                    *write = *b; // copy  value to front (test is not true)
                }
                //std::cout << *dest << std::endl;
                comp = write++;
                ++b;
            }
                }

    return write;
}



}
}
#endif // ContainerFunctions_hpp