Instigate Open Source Documentation

---

src/stl/_prev_permutation.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_PREV_PERMUTATION_HPP
#define INSTIGATE_STL_PREV_PERMUTATION_HPP

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

// Headers from other project

// Headers from standard library

// Forward declaration
namespace instigate {
        namespace stl {
                template <typename I>
                bool prev_permutation(I b, I e);
                template <typename I, typename C>
                bool prev_permutation(I b, I e, C c);
        }
}

template <typename I>
bool instigate::stl::prev_permutation(I b, I e)
{
        namespace BI = instigate::stl::bidirectional_iterator;
        typedef typename instigate::stl::readable_iterator::interface<I>::
                        value_type value_type;
        CHECK(instigate::stl::bidirectional_iterator::requirements<I>);
        CHECK(instigate::stl::readable_iterator::requirements<I>);
        if(equal(b, e)) {
                return false;
        }
        char k[sizeof(I)];
        I* i = 0;;
        assign(i, copy_constructor(k, b));
        assert(0 != i);
        increment(*i);
        if (equal(*i, e)) {
                return false;
        }
        assign(*i, e);
        decrement(*i);
        for(;;) {
                char k1[sizeof(I)];
                I* ii = 0;;
                assign(ii, copy_constructor(k1, *i));
                assert(0 != ii);
                decrement(*i);
                if (less_than(const_dereference(*ii), const_dereference(*i))) { 
                        char k2[sizeof(I)];
                        I* j = 0;;
                        assign(j, copy_constructor(k2, e));
                        assert(0 != j);
                        decrement(*j);
                        while(!less_than(const_dereference(*j), 
                                                const_dereference(*i)))
                        {
                                decrement(*j);
                        }
                        instigate::stl::iter_swap(*i, *j);
                        instigate::stl::reverse(*ii, e);
                        return true;
                }
                if (equal(*i, b)) {
                        instigate::stl::reverse(b, e);
                        return false;
                }
        }
}                               

template <typename I, typename C>
bool instigate::stl::prev_permutation(I b, I e, C c)
{
        typedef typename instigate::stl::readable_iterator::interface<I>::
                value_type value_type;
        CHECK(instigate::stl::bidirectional_iterator::requirements<I>);
        CHECK(instigate::stl::readable_iterator::requirements<I>);
        CHECK(instigate::stl::binary_predicate::requirements<C>);
        if (equal(b, e)) {
                return false;
        }
        char k[sizeof(I)];
        I* i = 0;;
        assign(i, copy_constructor(k, b));
        assert(0 != i);
        increment(*i);
        if (equal(*i, e)) {
                return false;
        }
        assign(*i, e);
        decrement(*i);
        for (;;) {
                char k1[sizeof(I)];
                I* ii = 0;;
                assign(ii, copy_constructor(k1, *i));
                assert(0 != ii);
                decrement(*i);
                if (invoke_predicate(c, const_dereference(*ii), 
                                                const_dereference(*i))) 
                {     
                        char k2[sizeof(I)];
                        I* j = 0;;
                        assign(j, copy_constructor(k2, e));
                        assert(0 != j);
                        decrement(*j);
                        while (!invoke_predicate(c, const_dereference(*j), 
                                                        const_dereference(*i))) 
                        {
                                decrement(*j);
                        }
                        instigate::stl::iter_swap(*i, *j);
                        instigate::stl::reverse(*ii, e);
                        return true;
                }
                if (equal(*i, b)) {
                        instigate::stl::reverse(b, e);
                        return false;
                }
        }
}                                       

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

#endif // INSTIGATE_STL_PREV_PERMUTATION_HPP

---

© Instigate CJSC, Open Source