Instigate Open Source Documentation

---

src/stl/_set_symmetric_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_SET_SYMMETRIC_DIFFERENCE_HPP
#define INSTIGATE_STL_SET_SYMMETRIC_DIFFERENCE_HPP

// headers from this project
#include "concept.hpp"
#include "_copy.hpp"

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

// headers from standard library

// forward declaration
namespace instigate {
        namespace stl {
                template <typename I, typename I1, typename O>
                O set_symmetric_difference(I b, I e, I1 f, I1 l, O r);
                template <typename I, typename I1, typename O, typename BP>
                O set_symmetric_difference(I b, I e, I1 f, I1 l, O r, BP p);
        }
}

template <typename I, typename I1, typename O>
O instigate::stl::set_symmetric_difference(I b, I e, I1 f, I1 l, O r)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace EQ = instigate::generic::equality_comparable;
        namespace LT = instigate::generic::less_than_comparable;
        namespace INC = instigate::stl::incrementable_iterator;
        namespace WR = instigate::stl::writable_iterator;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I1>);
        CHECK(RI::requirements<I1>);
        CHECK(INC::requirements<O>);
        CHECK(WR::requirements<O>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I1>::value_type value_type2;
        CHECK_SAME_TYPE(value_type1, value_type2);      
        CHECK_CONVERTIBILITY(value_type1, value_type2);
        CHECK(LT::requirements<value_type1>);
        while (!equal(b, e) && !equal(f, l)) {
                if (less_than(const_dereference(b), const_dereference(f))) {
                        dereference_assign(r, const_dereference(b));
                        increment(b);
                        increment(r);
                }
                else if (less_than(const_dereference(f),const_dereference(b)))
                {
                        dereference_assign(r, const_dereference(f));
                        increment(f);
                        increment(r);
                } else {
                        increment(b);
                        increment(f);
                }
        }
        return instigate::stl::copy(f, l, instigate::stl::copy(b, e, r));
}

template <typename I, typename I1, typename O, typename BP>
O instigate::stl::set_symmetric_difference(I b, I e, I1 f, I1 l, O r, BP p)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace EQ = instigate::generic::equality_comparable;
        namespace LT = instigate::generic::less_than_comparable;
        namespace INC = instigate::stl::incrementable_iterator;
        namespace WR = instigate::stl::writable_iterator;
        namespace BPI = instigate::stl::binary_predicate;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(SP::requirements<I1>);
        CHECK(RI::requirements<I1>);
        CHECK(INC::requirements<O>);
        CHECK(WR::requirements<O>);
        CHECK(BPI::requirements<BP>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename RI::interface<I1>::value_type value_type2;
        typedef typename WR::interface<O>::value_type value_type3;
        typedef typename BPI::interface<BP>::first_argument_type 
                first_argument_type;
        typedef typename BPI::interface<BP>::second_argument_type 
                second_argument_type;
        CHECK_SAME_TYPE(value_type1, value_type2);      
        CHECK_CONVERTIBILITY(value_type1, value_type3);
        CHECK_CONVERTIBILITY(value_type2, value_type3);
        CHECK_CONVERTIBILITY(value_type1, first_argument_type);
        CHECK_CONVERTIBILITY(value_type2, second_argument_type);
        while (!equal(b, e) && !equal(f, l)) {
                if (invoke_predicate(p, const_dereference(b), 
                                const_dereference(f))) 
                {
                        dereference_assign(r, const_dereference(b));
                        increment(b);
                        increment(r);
                }
                else if (invoke_predicate(p, const_dereference(f), 
                                const_dereference(b))) 
                {
                        dereference_assign(r, const_dereference(f));
                        increment(f);
                        increment(r);
                } else {
                        increment(b);
                        increment(f);
                }
        }
        return instigate::stl::copy(f, l, instigate::stl::copy(b, e, r));
}

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

#endif // INSTIGATE_STL_SET_SYMMETRIC_DIFFERENCE_HPP

---

© Instigate CJSC, Open Source