Instigate Open Source Documentation

---

src/stl/_adjacent_difference.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_ADJACENT_DIFFERENCE_HPP
#define INSTIGATE_STL_ADJACENT_DIFFERENCE_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 {
                namespace implementation {
                        template <typename F, typename O, typename T>
                        O adjacent_difference_aux(F b, F e, O r, T*);
                        template <typename F, typename O, typename T, 
                                 typename BF>
                        O adjacent_difference_aux(F b, F e, O r, T*, BF f);
                }
                template <typename F, typename O>
                O adjacent_difference(F b, F e, O r);
                template <typename F, typename O, typename BF>
                O adjacent_difference(F b, F e, O r, BF f);
        }
}

template <typename F, typename O>
O instigate::stl::adjacent_difference(F b, F e, O r)
{
        namespace FI = instigate::stl::forward_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace INC = instigate::stl::incrementable_iterator;
        namespace WR = instigate::stl::writable_iterator;
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(INC::requirements<O>);
        CHECK(WR::requirements<O>);
        typedef typename RI::interface<F>::value_type value_type;
        CHECK_CONVERTIBILITY(value_type, typename WR::interface<O>::value_type);
        if (equal(b, e)) {
                return r;
        }
        dereference_assign(r, const_dereference(b));
        value_type* k = 0;
        return instigate::stl::implementation::
                adjacent_difference_aux(b, e, r, k);
}                                       

template <typename F, typename O, typename T>
O instigate::stl::implementation::adjacent_difference_aux(F b, F e, O r, T*)
{
        T v;
        assign(v, const_dereference(b));
        increment(b);
        while (!equal(b, e)) {
                T t;
                assign(t, const_dereference(b));
                increment(r);
                dereference_assign(r, t - v);
                assign(v, t);
                increment(b);
        }
        increment(r);
        return r;
}

template <typename F, typename O, typename BF>
O instigate::stl::adjacent_difference(F b, F e, O r, BF f)
{
        namespace FI = instigate::stl::forward_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace INC = instigate::stl::incrementable_iterator;
        namespace WR = instigate::stl::writable_iterator;
        namespace BFI = instigate::stl::binary_function;
        CHECK(FI::requirements<F>);
        CHECK(RI::requirements<F>);
        CHECK(INC::requirements<O>);
        CHECK(WR::requirements<O>);
        typedef typename RI::interface<F>::value_type value_type1;
        typedef typename BFI::interface<BF>::first_argument_type 
                                                        first_argument_type;
        typedef typename BFI::interface<BF>::second_argument_type 
                                                        second_argument_type;
        typedef typename WR::interface<O>::value_type value_type2;
        typedef typename BFI::interface<BF>::result_type result_type;
        CHECK_CONVERTIBILITY(value_type1, first_argument_type);
        CHECK_CONVERTIBILITY(value_type1, second_argument_type);
        CHECK_CONVERTIBILITY(value_type1, value_type2);
        CHECK_CONVERTIBILITY(result_type, value_type2);
        if (equal(b, e)) {
                return r;
        }
        dereference_assign(r, const_dereference(b));
        value_type1* k = 0;
        return instigate::stl::implementation::
                adjacent_difference_aux(b, e, r, k, f);
}

template <typename F, typename O, typename T, typename BF>
O instigate::stl::implementation::
                        adjacent_difference_aux(F b, F e, O r, T*, BF f)
{
        T v;
        assign(v, const_dereference(b));
        increment(b);
        while (!equal(b, e)) {
                T t;
                assign(t, const_dereference(b));
                increment(r);
                dereference_assign(r, invoke(f, t, v));
                assign(v, t);
                increment(b);
        }
        increment(r);
        return r;
}

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

#endif // INSTIGATE_STL_ADJACENT_DIFFERENCE_HPP

---

© Instigate CJSC, Open Source