Instigate Open Source Documentation

---

src/stl/_max_element.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_MAX_ELEMENT_HPP
#define INSTIGATE_STL_MAX_ELEMENT_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 F>
                F max_element(F b, F e);
                template <typename F, typename BP>
                F max_element(F b, F e, BP p);
        }
}

template <typename F>
F instigate::stl::max_element(F b, F e)
{
        namespace FI = instigate::stl::forward_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace LT = instigate::generic::less_than_comparable;
        typedef typename RI::interface<F>::value_type value_type;
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(LT::requirements<value_type>);
        if (equal(b, e)) {
                return b;
        }
        char k[sizeof(F)];
        F* r = 0;
        assign(r, copy_constructor(k, b));
        assert(0 != r);
        increment(b);
        while (!equal(b, e)) {
                if (less_than(const_dereference(*r), const_dereference(b))) {
                        assign(*r, b);
                }
                increment(b);
        }
        return *r;
}

template <typename F, typename BP>
F instigate::stl::max_element(F b, F e, BP p)
{
        namespace FI = instigate::stl::forward_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace BPI = instigate::stl::binary_predicate;
        typedef typename RI::interface<F>::value_type value_type;
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(BPI::requirements<BP>);
        typedef typename RI::interface<F>::value_type value_type;
        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_type, first_argument_type);
        CHECK_CONVERTIBILITY(value_type, second_argument_type);
        if (equal(b, e)) {
                return b;
        }
        char k[sizeof(F)];
        F* r = 0;
        assign(r, copy_constructor(k, b));
        assert(0 != r);
        increment(b);
        while (!equal(b, e)) {
                if (invoke_predicate(p, const_dereference(*r),
                                        const_dereference(b))) 
                {
                        assign(*r, b);
                }
                increment(b);
        }
        return *r;
}

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

#endif // INSTIGATE_STL_MAX_ELEMENT_HPP

---

© Instigate CJSC, Open Source