Instigate Open Source Documentation

---

src/stl/_find_first_of.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_STL_INTERNAL_HEADER_IN_ALGORITHM
#error This is an internal header file used to implement Instigate STL.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_STL_FIND_FIRST_OF_HPP
#define INSTIGATE_STL_FIND_FIRST_OF_HPP


// Headers from this project
#include "concept.hpp"
#include "_basis.hpp"

// Headers from other project

// Headers from standard library

// Forward declaration
namespace instigate {
        namespace stl {
                template <typename I, typename F>
                I find_first_of(I b, I e, F f, F l);
                template <typename I, typename F, typename BP>
                I find_first_of(I b, I e, F f, F l, BP p);
        }
}

template <typename I, typename F>
I instigate::stl::find_first_of(I b, I e, F f, F l)
{
        namespace SP = instigate::stl::single_pass_iterator; 
        namespace RI = instigate::stl::readable_iterator; 
        namespace FI = instigate::stl::forward_iterator; 
        namespace EQ = instigate::generic::equality_comparable; 
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I>);
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(EQ::requirements<typename RI::interface<I>::value_type>);
        char p[sizeof(F)];
        while (!equal(b, e)) {
                F* i = 0;
                assign(i, copy_constructor(p, f));
                assert(0 != i);
                while (!equal((*i), l)) {
                        if (equal(const_dereference(b), const_dereference(*i)))
                        {
                                return b;
                        }
                        increment(*i);
                }
                increment(b);
        }
        return e;
}

template <typename I, typename F, typename BP>
I instigate::stl::find_first_of(I b, I e, F f, F l, BP p)
{
        namespace SP = instigate::stl::single_pass_iterator; 
        namespace RI = instigate::stl::readable_iterator; 
        namespace FI = instigate::stl::forward_iterator; 
        namespace EQ = instigate::generic::equality_comparable; 
        namespace BPI = instigate::stl::binary_predicate;
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I>);
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(BPI::requirements<BP>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<F>::value_type value_type2;
        typedef typename BPI::interface<BP>::
                first_argument_type first_argument_type;
        typedef typename BPI::interface<BP>::
                second_argument_type second_argument_type;
        CHECK_CONVERTIBILITY(value_type1, first_argument_type);
        CHECK_CONVERTIBILITY(value_type2, second_argument_type);
        char t[sizeof(F)];
        while (!equal(b, e)) {
                F* i = 0;
                assign(i, copy_constructor(t, f));
                assert(0 != i);
                while (!equal((*i), l)) {
                        if (invoke_predicate(p, const_dereference(b),
                                                const_dereference(*i))) 
                        {
                                return b;
                        }
                        increment(*i);
                }
                increment(b);
        }
        return e;
}

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_FIND_FIRST_OF_HPP

---

© Instigate CJSC, Open Source