Instigate Open Source Documentation

---

src/stl/_random_shuffle.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_RANDOM_SHUFFLE_HPP
#define INSTIGATE_STL_RANDOM_SHUFFLE_HPP

// headers from this project
#include "concept.hpp"
#include "_random_number.hpp"
#include "_iter_swap.hpp"
#include "_advance.hpp"
#include "_distance.hpp"
#include "_basis.hpp"

// headers from other project

// headers from standard library

// forward declaration
namespace instigate {
        namespace stl {
                template <typename R>
                inline void random_shuffle(R f, R l);
                template <typename R, typename G>
                void random_shuffle(R f, R l, G& g);
        }
}

template <typename R>
inline void instigate::stl::random_shuffle(R f, R l)
{
        namespace RA = instigate::stl::random_access_iterator;
        namespace WR = instigate::stl::writable_iterator;
        CHECK(RA::requirements<R>);
        CHECK(WR::requirements<R>);
        if (equal(f, l)) {
                return;
        }
        char k[sizeof(R)];
        R* i = 0;
        assign(i, copy_constructor(k, f));
        assert(0 != i);
        increment(*i);
        char p[sizeof(R)];
        R* t = 0;
        assign(t, initialize<R>(p));
        while (!equal(*i, l)) {
                assert(0 != t);
                assign(*t, f);
                instigate::stl::advance(*t, 
                                instigate::stl::random_number(
                                        instigate::stl::distance(f, *i) + 1));
                instigate::stl::iter_swap(*i, *t);
                increment(*i);
        }
}

template <typename R, typename G>
void instigate::stl::random_shuffle(R f, R l, G& g)
{
        namespace RA = instigate::stl::random_access_iterator;
        namespace WR = instigate::stl::writable_iterator;
        namespace UF = instigate::stl::unary_function;
        CHECK(RA::requirements<R>);
        CHECK(WR::requirements<R>);
        CHECK(UF::requirements<G>);
        typedef typename RA::interface<R>::difference_type difference_type;
        typedef typename UF::interface<G>::argument_type argument_type;
        CHECK_CONVERTIBILITY(difference_type, argument_type);
        if (equal(f, l)) {
                return;
        }
        char k[sizeof(R)];
        R* i = 0;
        assign(i, copy_constructor(k, f));
        assert(0 != i);
        increment(*i);
        char p[sizeof(R)];
        R* t = 0;
        assign(t, initialize<R>(p));
        while (!equal(*i, l)) {
                assert(0 != t);
                assign(*t, f);
                instigate::stl::advance( *t, invoke(g,
                                        (int)instigate::stl::distance(f, *i) + 1));
                instigate::stl::iter_swap(*i, *t);
                increment(*i);
        }
}

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

#endif // INSTIGATE_STL_RANDOM_SHUFFLE_HPP

---

© Instigate CJSC, Open Source