copy_help.h

// Copyright (c) Electronic Arts Inc. All rights reserved.
 
 
#ifndef EASTL_INTERNAL_COPY_HELP_H
#define EASTL_INTERNAL_COPY_HELP_H
 
#include <EASTL/internal/config.h>
 
#if defined(EA_PRAGMA_ONCE_SUPPORTED)
    #pragma once
#endif
 
#include <EASTL/type_traits.h>
#include <EASTL/iterator.h>
 
 
namespace eastl
{
 
    // Implementation moving copying both trivial and non-trivial data via a lesser iterator than random-access.
    template <typename /*InputIteratorCategory*/, bool /*isMove*/, bool /*canMemmove*/>
    struct move_and_copy_helper
    {
        template <typename InputIterator, typename OutputIterator>
        static OutputIterator move_or_copy(InputIterator first, InputIterator last, OutputIterator result)
        {
            for(; first != last; ++result, ++first)
                *result = *first;
            return result;
        }
    };
 
    // Specialization for copying non-trivial data via a random-access iterator. It's theoretically faster because the compiler can see the count when its a compile-time const.
    // This specialization converts the random access InputIterator last-first to an integral type. There's simple way for us to take advantage of a random access output iterator,
    // as the range is specified by the input instead of the output, and distance(first, last) for a non-random-access iterator is potentially slow.
    template <>
    struct move_and_copy_helper<EASTL_ITC_NS::random_access_iterator_tag, false, false>
    {
        template <typename InputIterator, typename OutputIterator>
        static OutputIterator move_or_copy(InputIterator first, InputIterator last, OutputIterator result)
        {
            typedef typename eastl::iterator_traits<InputIterator>::difference_type difference_type;
 
            for(difference_type n = (last - first); n > 0; --n, ++first, ++result)
                *result = *first;
 
            return result;
        }
    };
 
    // Specialization for moving non-trivial data via a lesser iterator than random-access.
    template <typename InputIteratorCategory>
    struct move_and_copy_helper<InputIteratorCategory, true, false>
    {
        template <typename InputIterator, typename OutputIterator>
        static OutputIterator move_or_copy(InputIterator first, InputIterator last, OutputIterator result)
        {
            for(; first != last; ++result, ++first)
                *result = eastl::move(*first);
            return result;
        }
    };
 
    // Specialization for moving non-trivial data via a random-access iterator. It's theoretically faster because the compiler can see the count when its a compile-time const.
    template <>
    struct move_and_copy_helper<EASTL_ITC_NS::random_access_iterator_tag, true, false>
    {
        template <typename InputIterator, typename OutputIterator>
        static OutputIterator move_or_copy(InputIterator first, InputIterator last, OutputIterator result)
        {
            typedef typename eastl::iterator_traits<InputIterator>::difference_type difference_type;
 
            for(difference_type n = (last - first); n > 0; --n, ++first, ++result)
                *result = eastl::move(*first);
 
            return result;
        }
    };
 
    // Specialization for when we can use memmove/memcpy. See the notes above for what conditions allow this.
    template <bool isMove>
    struct move_and_copy_helper<EASTL_ITC_NS::random_access_iterator_tag, isMove, true>
    {
        template <typename T>
        static T* move_or_copy(const T* first, const T* last, T* result)
        {
            if (EASTL_UNLIKELY(first == last))
                return result;
 
            // We could use memcpy here if there's no range overlap, but memcpy is rarely much faster than memmove.
            return (T*)__builtin_memmove(result, first, (size_t)((uintptr_t)last - (uintptr_t)first)) + (last - first);
        }
    };
 
 
 
    template <bool isMove, typename InputIterator, typename OutputIterator>
    inline OutputIterator move_and_copy_chooser(InputIterator first, InputIterator last, OutputIterator result)
    {
        typedef typename eastl::iterator_traits<InputIterator>::iterator_category  IIC;
        typedef typename eastl::iterator_traits<OutputIterator>::iterator_category OIC;
        typedef typename eastl::iterator_traits<InputIterator>::value_type         value_type_input;
        typedef typename eastl::iterator_traits<OutputIterator>::value_type        value_type_output;
 
        const bool canBeMemmoved = eastl::is_trivially_copyable<value_type_output>::value &&
                                   eastl::is_same<value_type_input, value_type_output>::value &&
                                  (eastl::is_pointer<InputIterator>::value  || eastl::is_same<IIC, eastl::contiguous_iterator_tag>::value) &&
                                  (eastl::is_pointer<OutputIterator>::value || eastl::is_same<OIC, eastl::contiguous_iterator_tag>::value);
 
        return eastl::move_and_copy_helper<IIC, isMove, canBeMemmoved>::move_or_copy(first, last, result); // Need to chose based on the input iterator tag and not the output iterator tag, because containers accept input ranges of iterator types different than self.
    }
 
 
    // We have a second layer of unwrap_iterator calls because the original iterator might be something like move_iterator<generic_iterator<int*> > (i.e. doubly-wrapped).
    template <bool isMove, typename InputIterator, typename OutputIterator>
    inline OutputIterator move_and_copy_unwrapper(InputIterator first, InputIterator last, OutputIterator result)
    {
        return OutputIterator(eastl::move_and_copy_chooser<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), eastl::unwrap_iterator(result))); // Have to convert to OutputIterator because result.base() could be a T*
    }
 
 
 
    template <typename InputIterator, typename OutputIterator>
    inline OutputIterator move(InputIterator first, InputIterator last, OutputIterator result)
    {
        return eastl::move_and_copy_unwrapper<true>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), result);
    }
 
 
    template <typename InputIterator, typename OutputIterator>
    inline OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result)
    {
        const bool isMove = eastl::is_move_iterator<InputIterator>::value; EA_UNUSED(isMove);
 
        return eastl::move_and_copy_unwrapper<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), result);
    }
} // namespace eastl
 
#endif // EASTL_INTERNAL_COPY_HELP_H