Instigate Open Source Documentation

---

src/stl/_copy.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_COPY_HPP
#define INSTIGATE_STL_COPY_HPP 

// Headers from this project
#include "concept.hpp"
#include "_basis.hpp"
#include "_distance.hpp"
#include "_advance.hpp"

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

// Headers from standard libraries

// Forward declaration
namespace instigate {
        namespace stl {
                template <typename I, typename O>
                inline O copy(I, I, O);

                namespace implementation {
                        template <typename I, typename O>
                        inline O __copy(I, I, O, 
                                instigate::stl::single_pass_iterator::tag);

                        template <typename I, typename O> 
                        inline O __copy(I, I, O, 
                                instigate::stl::random_access_iterator::tag);

                        template <typename T>
                        inline T* copy_trivial(const T*, const T*, T*);

                        template <typename I, typename O>
                        inline O copy_aux(I, I, O, false_type);

                        template <typename I, typename O>
                        inline O copy_aux(I, I, O, true_type);

                        template <typename T>
                        inline T* copy_aux(const T*, const T*, T*, true_type);
                }
        }
}

template <typename I, typename O>       
inline O instigate::stl::copy(I f, I l, O r)
{
        typedef typename instigate::stl::readable_iterator::
                interface<I>::value_type value_type1;
        typedef typename instigate::stl::writable_iterator::
                interface<O>::value_type value_type2;
        CHECK(instigate::stl::readable_iterator::requirements<I>);
        CHECK(instigate::stl::single_pass_iterator::requirements<I>);
        CHECK(instigate::stl::writable_iterator::requirements<O>);
        CHECK(instigate::stl::incrementable_iterator::requirements<O>);
        CHECK_CONVERTIBILITY(value_type1, value_type2);
        typedef typename unary_type_traits<value_type1>::
                has_trivial_assignment_operator trivial;
        return instigate::stl::implementation::copy_aux(f, l, r, trivial());
}

// All of these auxiliary functions serve two purposes. (1) Replace
// calls to copy with memmove whenever possible. (Memmove, not memcpy,
// because the input and output ranges are permitted to overlap.)
// (2) If we're using random access iterators, then write the loop as
// a for loop with an explicit count.

template <typename I, typename O>
inline O instigate::stl::implementation::__copy(I f, I l, O r,
        instigate::stl::single_pass_iterator::tag)
{
        for ( ; !equal(f, l); increment(r), increment(f)) {
                dereference_assign(r, const_dereference(f));
        }
        return r;
}

template <typename I, typename O>
inline O instigate::stl::implementation::__copy(I f, I l, O r, 
        instigate::stl::random_access_iterator::tag)
{
        typedef typename instigate::stl::random_access_iterator::
                interface<I>::difference_type DISTANCE;
        for (DISTANCE n = instigate::stl::distance<I>(f,l); n > 0; --n) {
                dereference_assign(r, const_dereference(f));
                increment(r), 
                increment(f);
        }
        return r;
}

template <typename T>
inline T* instigate::stl::implementation::copy_trivial(
                                        const T* f, const T* l, T* r)
{
        memmove(r, f, sizeof(T) * instigate::stl::distance(f, l));
        instigate::stl::advance(r, instigate::stl::distance(f, l));
        return r;
}

template <typename I, typename O>
inline O instigate::stl::implementation::copy_aux(I f, I l, O r, false_type)
{
        return instigate::stl::implementation::__copy(f, l, r,
                typename instigate::stl::single_pass_iterator::interface<I>::
                        iterator_category());
}

template <typename I, typename O>
inline O instigate::stl::implementation::copy_aux(I f, I l, O r, true_type)
{
        return instigate::stl::implementation::__copy(f, l, r,
                typename instigate::stl::single_pass_iterator::interface<I>::
                        iterator_category());
}

template <typename T>
inline T* instigate::stl::implementation::copy_aux(const T* f, const T* l, 
                                                        T* r, true_type)
{
        return instigate::stl::implementation::copy_trivial(f, l, r);
}

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

#endif // INSTIGATE_STL_COPY_HPP

---

© Instigate CJSC, Open Source