Instigate Open Source Documentation

---

src/stl/_mismatch.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_MISMATCH_HPP
#define INSTIGATE_STL_MISMATCH_HPP

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

// headers from other projects

// headers from standard libraries

// Forward declaration
namespace instigate {
        namespace stl {
                        template <typename I, typename I2, typename P>
                        inline void mismatch(I b, I e, I2 f, P& r);
                        template <typename I, typename I2, typename B, 
                                 typename P>
                        inline void mismatch(I b, I e, I2 f,B p, P& r);
        }
}

template <typename I, typename I2, typename P>
inline void instigate::stl::mismatch(I b, I e, I2 f, P& r)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace PR = instigate::stl::pair;
        namespace EQ = instigate::generic::equality_comparable;
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I>::value_type value_type2;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I2>);
        CHECK(RI::requirements<I2>);
        CHECK(PR::requirements<P>);
        CHECK(EQ::requirements<value_type1>);
        CHECK(EQ::requirements<value_type2>);
        while (!equal(b, e) && equal(const_dereference(b), 
                                const_dereference(f))) {
                increment(b);
                increment(f);
        }
        assign(r.first, b);
        assign(r.second, f);
}

template <typename I, typename I2, typename B, typename P>
inline void instigate::stl::mismatch(I b, I e, I2 f, B p, P& r)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace PR = instigate::stl::pair;
        namespace EQ = instigate::generic::equality_comparable;
        namespace BP = instigate::stl::binary_predicate;
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I>::value_type value_type2;
        typedef typename BP::interface<B>::first_argument_type 
                first_argument_type;
        typedef typename BP::interface<B>::second_argument_type
                second_argument_type;
        typedef typename BP::interface<B>::result_type result_type;
        CHECK_CONVERTIBILITY(value_type1, first_argument_type);
        CHECK_CONVERTIBILITY(value_type2, second_argument_type);
        CHECK_CONVERTIBILITY(result_type, bool);
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I2>);
        CHECK(RI::requirements<I2>);
        CHECK(PR::requirements<P>);
        CHECK(BP::requirements<B>);
        while (!equal(b, e) && 
                        invoke_predicate(p, const_dereference(b), 
                                const_dereference(f))) 
        {
                increment(b);
                increment(f);
        }
        assign(r.first, b);
        assign(r.second, f);
}

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

#endif // INSTIGATE_STL_MISMATCH_HPP

---

© Instigate CJSC, Open Source