Instigate Open Source Documentation

---

src/stl/_make_heap.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_MAKE_HEAP_HPP
#define INSTIGATE_STL_MAKE_HEAP_HPP

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

// headers from other project
#include <generic/base.hpp>        

// headers from standard library

// forward declaration

namespace instigate {
        namespace stl {
                template <typename I>
                void make_heap(I, I);

                template <typename I, typename C>
                void make_heap(I, I, C);
        }
}

template <typename I>
void instigate::stl::make_heap(I b, I e)
{
        typedef typename stl::random_access_iterator::interface<I>::
                difference_type D;
        typedef typename stl::readable_iterator::interface<I>::value_type V;
        CHECK(stl::random_access_iterator::requirements<I>);
        CHECK(stl::lvalue_iterator::requirements<I>);
        CHECK(instigate::generic::less_than_comparable::requirements<V>);
        if (stl::distance(b, e) < 2) {
                return;
        }
        D l =  stl::distance(b, e);
        D p = (l - 2) / 2;
        char buf[sizeof(I)];
        I* buf_p = 0;
        assign(buf_p, initialize<I>(buf));
        while (true) {
                assert(0 != buf_p);
                assign(*buf_p, b);
                stl::advance(*buf_p, p);
                implementation::adjust_heap_aux(b, p, l, 
                        const_dereference(*buf_p));
                if (0 == p) {
                        return;
                }
                --p;
        }
}                                       

template <typename I, typename C>
void instigate::stl::make_heap(I b, I e, C c)
{
        typedef typename stl::random_access_iterator::interface<I>::
                difference_type D;
        CHECK(stl::random_access_iterator::requirements<I>);
        CHECK(stl::lvalue_iterator::requirements<I>);
        CHECK(stl::binary_predicate::requirements<C>);
        if (stl::distance(b, e) < 2) {
                return;
        }
        D l = stl::distance(b, e);
        D p = (l - 2) / 2;
        char buf[sizeof(I)];
        I* buf_p = 0;
        assign(buf_p, initialize<I>(buf));
        while (true) {
                assert(0 != buf_p);
                assign(*buf_p, b);
                stl::advance(*buf_p, p);
                implementation::adjust_heap_aux(b, p, l, 
                        const_dereference(*buf_p), c);
                if (0 == p) {
                       return;
                }
                --p;
        }
}                                       

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

#endif // INSTIGATE_STL_MAKE_HEAP_HPP

---

© Instigate CJSC, Open Source