filter.hpp

Go to the documentation of this file.

/*
 *   Copyright 2021 Huawei Technologies Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _H_ALP_UTILS_ITERATORS_FILTER
#define _H_ALP_UTILS_ITERATORS_FILTER

#include <iterator>


namespace grb {

    namespace utils {

        namespace iterators {

            template< typename FwdSubIter >
            class IteratorFilter;

            template< typename FwdSubIter >
            IteratorFilter< FwdSubIter > make_filtered_iterator(
                FwdSubIter begin, const FwdSubIter end,
                const std::function< bool(const typename FwdSubIter::value_type &) > func
            );

            template< typename FwdSubIter >
            class IteratorFilter {

                static_assert( std::is_base_of<
                        std::forward_iterator_tag,
                        typename std::iterator_traits< FwdSubIter >::iterator_category
                    >::value,
                    "The sub-iterator to IteratorFilter must be a forward iterator."
                );


                protected:

                    typedef typename std::iterator_traits< FwdSubIter >::value_type ValT;

                    typedef typename std::function< bool( const ValT & ) > FilterT;


                private:

                    typedef IteratorFilter< FwdSubIter > self_type;

                    FwdSubIter it;

                    const FwdSubIter end;

                    FilterT filter;


                protected:

                    IteratorFilter(
                        FwdSubIter it_in, const FwdSubIter end_in,
                        const FilterT func_in
                    ) :
                        it( it_in ), end( end_in ), filter( func_in )
                    {}


                public:

                    // friend functions

                    friend void swap(
                        IteratorFilter< FwdSubIter > &left, IteratorFilter< FwdSubIter > &right
                    ) noexcept {
                        std::swap( left.it, right.it );
                        std::swap( left.end, right.end );
                        std::swap( left.filter, right.filter );
                    }

                    template< typename T >
                    friend IteratorFilter< T > make_filtered_iterator(
                        T begin, const T end,
                        const std::function< bool(const typename T::value_type &) > func
                    );

                    // STL typedefs

                    typedef typename std::iterator_traits< self_type >::difference_type
                        difference_type;
                    typedef typename std::iterator_traits< self_type >::value_type value_type;
                    typedef typename std::iterator_traits< self_type >::pointer pointer;
                    typedef typename std::iterator_traits< self_type >::reference reference;
                    typedef typename std::iterator_traits< self_type >::iterator_category
                        iterator_category;

                    IteratorFilter() = delete;

                    IteratorFilter( const IteratorFilter< FwdSubIter > &toCopy ) :
                        it( toCopy.it ), end( toCopy.end ), filter( toCopy.filter )
                    {}

                    ~IteratorFilter() {}

                    IteratorFilter< FwdSubIter >& operator=(
                        const IteratorFilter< FwdSubIter > &toCopy
                    ) {
                        it = toCopy.it;
                        filter = toCopy.filter;
                        return *this;
                    }

                    IteratorFilter< FwdSubIter >& operator++() {
                        (void) ++it;
                        while( it != end && filter( *it ) ) {
                            (void) ++it;
                        }
                        return *this;
                    }

                    IteratorFilter< FwdSubIter > operator++(int) {
                        IteratorFilter< FwdSubIter > ret( *this );
                        (void) it++;
                        while( it != end && filter( *it ) ) {
                            (void) it++;
                        }
                        return ret;
                    }

                    reference operator*() const {
                        return *it;
                    }

                    pointer operator->() const {
                        return it.operator->();
                    }

                    bool operator==( const IteratorFilter< FwdSubIter >& other ) const {
                        return it == other.it;
                    }

                    bool operator!=( const IteratorFilter< FwdSubIter >& other ) const {
                        return it != other.it;
                    }

            };

            template< typename FwdSubIter >
            IteratorFilter< FwdSubIter > make_filtered_iterator(
                FwdSubIter begin, const FwdSubIter end,
                const std::function< bool(const typename FwdSubIter::value_type &) > func
            ) {
                IteratorFilter< FwdSubIter > ret =
                    IteratorFilter< FwdSubIter >( begin, end, func );
                if( begin != end ) {
                    while( begin != end && func( *begin ) ) {
                        (void) ++begin;
                    }
                    ret = IteratorFilter< FwdSubIter >( begin, end, func );
                }
                return ret;
            }

        } // end grb::utils::iterators namespace

    } // end grb::utils namespace

} // end grb namespace

namespace std {

    template< typename FwdSubIter >
    struct iterator_traits<
        grb::utils::iterators::IteratorFilter< FwdSubIter >
    > {

        typedef typename std::iterator_traits< FwdSubIter >::difference_type
            difference_type;

        typedef typename std::iterator_traits< FwdSubIter >::value_type value_type;

        typedef typename std::iterator_traits< FwdSubIter >::pointer pointer;

        typedef typename std::iterator_traits< FwdSubIter >::reference reference;

        typedef typename std::forward_iterator_tag iterator_category;

    };

}

#endif // end _H_ALP_UTILS_ITERATORS_FILTER