private:

Container & container;

FilterFunc filter_func;

// The filter function is the only thing allowed to create a Filter

friend Filter filter<FilterFunc, Container>(FilterFunc,

Container &);

// Type of the Container::Iterator, but since the name of that

// iterator can be anything, we have to grab it with this

using contained_iter_type = decltype(container.begin());

// The type returned when dereferencing the Container::Iterator

using contained_iter_ret = decltype(container.begin().operator*());

// Value constructor for use only in the filter function

Filter(FilterFunc filter_func, Container & container) :

container(container),

filter_func(filter_func)

{ }

Filter () = delete;

Filter & operator=(const Filter &) = delete;

public:

Filter(const Filter &) = default;

class Iterator {

protected:

contained_iter_type sub_iter;

const contained_iter_type sub_end;

FilterFunc filter_func;

// increment until the iterator points to is true on the

// predicate. Called by constructor and operator++

void skip_failures() {

while (this->sub_iter != this->sub_end

&& !this->filter_func(*this->sub_iter)) {

++this->sub_iter;

}

}

public:

Iterator (contained_iter_type iter,

contained_iter_type end,

FilterFunc filter_func) :

sub_iter(iter),

sub_end(end),

filter_func(filter_func)

{

this->skip_failures();

}

contained_iter_ret operator*() const {

return *this->sub_iter;

}

Iterator & operator++() {

++this->sub_iter;

this->skip_failures();

return *this;

}

bool operator!=(const Iterator & other) const {

return this->sub_iter != other.sub_iter;

}

};

Iterator begin() const {

return Iterator(

this->container.begin(),

this->container.end(),

this->filter_func);

}

Iterator end() const {

return Iterator(

this->container.end(),

this->container.end(),

this->filter_func);

}

protected:

using contained_iter_ret =

decltype(std::declval<Container>().begin().operator*());

public:

bool operator() (const contained_iter_ret item) const {

return bool(item);

}