Instigate Open Source Documentation

---

src/stl/_search_n.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_SEARCH_N_HPP
#define INSTIGATE_STL_SEARCH_N_HPP

// headers from this project
#include "_basis.hpp"
#include "concept.hpp"
#include "_find.hpp"

// headers from other project

// headers from standard library

// forward declaration
namespace instigate {
        namespace stl {
                template <typename F, typename I, typename T>
                F search_n(F b, F e, I c, const T& v);
                template <typename F, typename I, typename T, typename P>
                F search_n(F b, F e, I c, const T& v, P p);
        }
}
template <typename F, typename I, typename T>
F instigate::stl::search_n(F b, F e, I c, const T& v)
{
        typedef typename instigate::stl::readable_iterator::interface<F>::
                        value_type value_type;
        CHECK(instigate::stl::forward_iterator::requirements<F>);
        CHECK(instigate::stl::readable_iterator::requirements<F>);
        CHECK(instigate::generic::less_than_comparable::requirements<I>);
        CHECK(instigate::generic::equality_comparable::
                                        requirements<value_type>);
        if (!less_than(0, c)) {
                return b;
        } else {
                b = instigate::stl::find(b, e, v);
                while (!equal(b, e)) {
                        I n = c - 1;
                        char k[sizeof(F)];
                        F* i = 0;
                        assign(i, copy_constructor(k, b));
                        assert(0 != i);
                        increment(*i);
                        while(!equal((*i), e) && !equal(0, n) &&
                                        equal(const_dereference(*i), v))
                        {
                                increment(*i);
                                assign(n, n - 1);
                        }
                        if (equal(0, n)) {
                                return b;
                        } else {
                                b = instigate::stl::find(*i, e, v);
                        }
                } 
                return e;
        }
}
template <typename F, typename I, typename T, typename P>
F instigate::stl::search_n(F b, F e, I c, const T& v, P p)
{
        typedef typename instigate::stl::readable_iterator::interface<F>::
                        value_type value_type;
        CHECK(instigate::stl::forward_iterator::requirements<F>);
        CHECK(instigate::stl::readable_iterator::requirements<F>);
        CHECK(instigate::generic::less_than_comparable::requirements<I>);
        CHECK(instigate::generic::equality_comparable::
                                        requirements<value_type>);
        CHECK(instigate::stl::binary_predicate::requirements<P>);
        if (!less_than(0, c)) {
                return b;
        } else {
                while (!equal(b, e)) {
                        if (invoke_predicate(p, *b, v)) {
                                break;
                        }
                        increment(b);
                }
                while (!equal(b, e)) {
                        I n = c - 1;
                        char k[sizeof(F)];
                        F* i = 0;
                        assign(i, copy_constructor(k, b));
                        assert(0 != i);
                        increment(*i);
                        while(!equal(*i, e) && !equal(0, n) && 
                                        invoke_predicate(p, 
                                                 const_dereference(*i), v))
                        {
                                increment(*i);
                                assign(n, n - 1);
                        }
                        if (equal(0, n)) {
                                return b;
                        } else {
                                while(!equal((*i), e)) {
                                       if(invoke_predicate(p, 
                                                const_dereference(*i), v)) 
                                       {
                                               break; 
                                       }
                                       increment(*i);
                                }
                                assign(b, (*i));
                        }
                }
                return e;
        }
}

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

#endif // INSTIGATE_STL_SEARCH_N_HPP

---

© Instigate CJSC, Open Source