memory_eastl.h

/*
Copyright (C) 2009-2010 Electronic Arts, Inc.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1.  Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
2.  Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
3.  Neither the name of Electronic Arts, Inc. ("EA") nor the names of
    its contributors may be used to endorse or promote products derived
    from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

// EASTL/memory.h
//
// Copyright (c) 2005, Electronic Arts. All rights reserved.
// Written and maintained by Paul Pedriana.
// The uninitialized_move function was written by Ryan Ingram.

// This file implements the following functions from the C++ standard that
// are found in the <memory> header:
//
// Temporary memory:
//    get_temporary_buffer
//    return_temporary_buffer
//
// Uninitialized operations:
//    These are the same as the copy, fill, and fill_n algorithms, except that
//    they *construct* the destination with the source values rather than assign
//    the destination with the source values.
//
//    uninitialized_copy
//    uninitialized_fill
//    uninitialized_fill_n
//    uninitialized_move          - Extention to standard functionality.
//    uninitialized_copy_ptr      - Extention to standard functionality.
//    uninitialized_fill_ptr      - Extention to standard functionality.
//    uninitialized_fill_n_ptr    - Extention to standard functionality.
//    uninitialized_copy_fill     - Extention to standard functionality.
//    uninitialized_fill_copy     - Extention to standard functionality.
//    uninitialized_copy_copy     - Extention to standard functionality.
//
// In-place destructor helpers:
//    destruct(T*)
//    destruct(first, last)
//


#ifndef EASTL_MEMORY_H
#define EASTL_MEMORY_H


#include <stk_util/util/config_eastl.h>
#include <stk_util/util/generic_iterator_eastl.h>
#include <stk_util/util/type_traits_eastl.h>
#include <stk_util/util/algorithm_eastl.h>
#include <stk_util/util/allocator_eastl.h>

#ifdef _MSC_VER
    #pragma warning(push, 0)
#endif
#include <stdlib.h>
#ifdef _MSC_VER
    #pragma warning(pop)
#endif

#ifdef _MSC_VER
    #pragma warning(push)
    #pragma warning(disable: 4530)  // C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
#endif


namespace eastl
{

    #ifndef EASTL_TEMP_DEFAULT_NAME
        #define EASTL_TEMP_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " temp" // Unless the user overrides something, this is "EASTL temp".
    #endif


    template <typename T>
    pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n, size_t alignment = 0, size_t alignmentOffset = 0, const char* pName = EASTL_TEMP_DEFAULT_NAME)
    {
        EASTLAllocatorType allocator(*EASTLAllocatorDefault(), pName);
        return eastl::pair<T*, ptrdiff_t>(static_cast<T*>(EASTLAllocAligned(allocator, n * sizeof(T), alignment, alignmentOffset)), n);
    }


    template <typename T>
    void return_temporary_buffer(T* p, ptrdiff_t n = 0)
    {
        EASTLAllocatorType& allocator(*EASTLAllocatorDefault());
        EASTLFree(allocator, p, n * sizeof(T));
    }




    template <bool hasTrivialMove, typename iteratorTag>
    struct uninitialized_move_impl
    {
        template <typename ForwardIterator, typename ForwardIteratorDest>
        static ForwardIteratorDest do_move_start(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
        {
            typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;

            #if EASTL_EXCEPTIONS_ENABLED
                ForwardIteratorDest origDest(dest);
                try
                {
                    for(; first != last; ++first, ++dest)
                        ::new(&*dest) value_type(*first);
                }
                catch(...)
                {
                    for(; origDest < dest; ++origDest)
                        origDest->~value_type();
                    throw;
                }
            #else
                for(; first != last; ++first, ++dest)
                    ::new(&*dest) value_type(*first);
            #endif

            return dest;
        }

        template <typename ForwardIterator, typename ForwardIteratorDest>
        static ForwardIteratorDest do_move_commit(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) //throw()
        {
            typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
            for(; first != last; ++first, ++dest)
                first->~value_type();

            return dest;
        }

        template <typename ForwardIterator, typename ForwardIteratorDest>
        static ForwardIteratorDest do_move_abort(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest) //throw()
        {
            typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
            for(; first != last; ++first, ++dest)
                dest->~value_type();
            return dest;
        }
    };

    template <>
    struct uninitialized_move_impl<true, EASTL_ITC_NS::random_access_iterator_tag>
    {
        template <typename T>
        static T* do_move_start(T* first, T* last, T* dest)
        {
            return (T*)memcpy(dest, first, (size_t)((uintptr_t)last - (uintptr_t)first)) + (last - first);
        }

        template <typename T>
        static T* do_move_commit(T* first, T* last, T* dest)
        {
            return dest + (last - first);
        }

        template <typename T>
        static T* do_move_abort(T* first, T* last, T* dest)
        {
            return dest + (last - first);
        }
    };


    template <typename ForwardIterator, typename ForwardIteratorDest>
    inline ForwardIteratorDest uninitialized_move_start(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::iterator_category IC;
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type_input;
        typedef typename eastl::iterator_traits<ForwardIteratorDest>::value_type value_type_output;

        const bool bHasTrivialMove = type_and<has_trivial_relocate<value_type_input>::value,
                                              is_pointer<ForwardIterator>::value,
                                              is_pointer<ForwardIteratorDest>::value,
                                              is_same<value_type_input, value_type_output>::value>::value;

        return eastl::uninitialized_move_impl<bHasTrivialMove, IC>::do_move_start(first, last, dest);
    }

    template <typename ForwardIterator, typename ForwardIteratorDest>
    inline ForwardIteratorDest uninitialized_move_commit(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::iterator_category IC;
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type_input;
        typedef typename eastl::iterator_traits<ForwardIteratorDest>::value_type value_type_output;

        const bool bHasTrivialMove = type_and<has_trivial_relocate<value_type_input>::value,
                                              is_pointer<ForwardIterator>::value,
                                              is_pointer<ForwardIteratorDest>::value,
                                              is_same<value_type_input, value_type_output>::value>::value;

        return eastl::uninitialized_move_impl<bHasTrivialMove, IC>::do_move_commit(first, last, dest);
    }

    template <typename ForwardIterator, typename ForwardIteratorDest>
    inline ForwardIteratorDest uninitialized_move_abort(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::iterator_category IC;
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type_input;
        typedef typename eastl::iterator_traits<ForwardIteratorDest>::value_type value_type_output;

        const bool bHasTrivialMove = type_and<has_trivial_relocate<value_type_input>::value,
                                              is_pointer<ForwardIterator>::value,
                                              is_pointer<ForwardIteratorDest>::value,
                                              is_same<value_type_input, value_type_output>::value>::value;

        return eastl::uninitialized_move_impl<bHasTrivialMove, IC>::do_move_abort(first, last, dest);
    }

    template <typename ForwardIterator, typename ForwardIteratorDest>
    inline ForwardIteratorDest uninitialized_move(ForwardIterator first, ForwardIterator last, ForwardIteratorDest dest)
    {
        ForwardIteratorDest result = uninitialized_move_start(first, last, dest);
        uninitialized_move_commit(first, last, dest);

        return result;
    }





    // uninitialized_copy
    //
    template <typename InputIterator, typename ForwardIterator>
    inline ForwardIterator uninitialized_copy_impl(InputIterator first, InputIterator last, ForwardIterator dest, true_type)
    {
        return eastl::copy(first, last, dest); // The copy() in turn will use memcpy for POD types.
    }

    template <typename InputIterator, typename ForwardIterator>
    inline ForwardIterator uninitialized_copy_impl(InputIterator first, InputIterator last, ForwardIterator dest, false_type)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        ForwardIterator currentDest(dest);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
                for(; first != last; ++first, ++currentDest)
                    ::new(&*currentDest) value_type(*first);
            }
            catch(...)
            {
                for(; dest < currentDest; ++dest)
                    dest->~value_type();
                throw;
            }
        #else
            for(; first != last; ++first, ++currentDest)
                ::new(&*currentDest) value_type(*first);
        #endif

        return currentDest;
    }

    template <typename InputIterator, typename ForwardIterator>
    inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;

        // Note: has_trivial_assign isn't actually the right thing to use here, as it
        // refers to assignment as opposed to construction. Bug Paul Pedriana if this
        // is becoming a problem. In the meantime, this code assumes that if has_trivial_assign
        // is present for a type, then has_trivial_copy is as well.
        return uninitialized_copy_impl(first, last, result, has_trivial_assign<value_type>());
    }

    template <typename First, typename Last, typename Result>
    inline Result uninitialized_copy_ptr(First first, Last last, Result result)
    {
        typedef typename eastl::iterator_traits<generic_iterator<Result, void> >::value_type value_type;
        const generic_iterator<Result, void> i(uninitialized_copy_impl(generic_iterator<First, void>(first),
                                                                       generic_iterator<Last, void>(last),
                                                                       generic_iterator<Result, void>(result),
                                                                       has_trivial_assign<value_type>()));
        return i.base();
    }




    // uninitialized_fill
    //
    template <typename ForwardIterator, typename T>
    inline void uninitialized_fill_impl(ForwardIterator first, ForwardIterator last, const T& value, true_type)
    {
        eastl::fill(first, last, value);
    }

    template <typename ForwardIterator, typename T>
    void uninitialized_fill_impl(ForwardIterator first, ForwardIterator last, const T& value, false_type)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        ForwardIterator currentDest(first);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
                for(; currentDest != last; ++currentDest)
                    ::new(&*currentDest) value_type(value);
            }
            catch(...)
            {
                for(; first < currentDest; ++first)
                    first->~value_type();
                throw;
            }
        #else
            for(; currentDest != last; ++currentDest)
                ::new(&*currentDest) value_type(value);
        #endif
    }

    template <typename ForwardIterator, typename T>
    inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& value)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        uninitialized_fill_impl(first, last, value, has_trivial_assign<value_type>());
    }

    template <typename T>
    inline void uninitialized_fill_ptr(T* first, T* last, const T& value)
    {
        typedef typename eastl::iterator_traits<generic_iterator<T*, void> >::value_type value_type;
        uninitialized_fill_impl(generic_iterator<T*, void>(first), generic_iterator<T*, void>(last), value, has_trivial_assign<value_type>());
    }




    // uninitialized_fill_n
    //
    template <typename ForwardIterator, typename Count, typename T>
    inline void uninitialized_fill_n_impl(ForwardIterator first, Count n, const T& value, true_type)
    {
        eastl::fill_n(first, n, value);
    }

    template <typename ForwardIterator, typename Count, typename T>
    void uninitialized_fill_n_impl(ForwardIterator first, Count n, const T& value, false_type)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        ForwardIterator currentDest(first);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
                for(; n > 0; --n, ++currentDest)
                    ::new(&*currentDest) value_type(value);
            }
            catch(...)
            {
                for(; first < currentDest; ++first)
                    first->~value_type();
                throw;
            }
        #else
            for(; n > 0; --n, ++currentDest)
                ::new(&*currentDest) value_type(value);
        #endif
    }

    template <typename ForwardIterator, typename Count, typename T>
    inline void uninitialized_fill_n(ForwardIterator first, Count n, const T& value)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        uninitialized_fill_n_impl(first, n, value, has_trivial_assign<value_type>());
    }

    template <typename T, typename Count>
    inline void uninitialized_fill_n_ptr(T* first, Count n, const T& value)
    {
        typedef typename eastl::iterator_traits<generic_iterator<T*, void> >::value_type value_type;
        uninitialized_fill_n_impl(generic_iterator<T*, void>(first), n, value, has_trivial_assign<value_type>());
    }




    template <typename InputIterator, typename ForwardIterator, typename T>
    inline void uninitialized_copy_fill(InputIterator first1, InputIterator last1,
                                        ForwardIterator first2, ForwardIterator last2, const T& value)
    {
        const ForwardIterator mid(eastl::uninitialized_copy(first1, last1, first2));

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                eastl::uninitialized_fill(mid, last2, value);
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                for(; first2 < mid; ++first2)
                    first2->~value_type();
                throw;
            }
        #endif
    }





    template <typename ForwardIterator, typename T, typename InputIterator>
    inline ForwardIterator
    uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid, const T& value, InputIterator first, InputIterator last)
    {
        eastl::uninitialized_fill(result, mid, value);

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                return eastl::uninitialized_copy(first, last, mid);
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                for(; result < mid; ++result)
                    result->~value_type();
                throw;
            }
        #endif
    }



    template <typename InputIterator1, typename InputIterator2, typename ForwardIterator>
    inline ForwardIterator
    uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
                            InputIterator2 first2, InputIterator2 last2,
                            ForwardIterator result)
    {
        const ForwardIterator mid(eastl::uninitialized_copy(first1, last1, result));

        #if EASTL_EXCEPTIONS_ENABLED
            try
            {
        #endif
                return eastl::uninitialized_copy(first2, last2, mid);
        #if EASTL_EXCEPTIONS_ENABLED
            }
            catch(...)
            {
                for(; result < mid; ++result)
                    result->~value_type();
                throw;
            }
        #endif
    }



    template <typename T>
    inline void destruct(T* p)
    {
        p->~T();
    }



    // destruct(first, last)
    //
    template <typename ForwardIterator>
    inline void destruct_impl(ForwardIterator /*first*/, ForwardIterator /*last*/, true_type) // true means the type has a trivial destructor.
    {
        // Empty. The type has a trivial destructor.
    }

    template <typename ForwardIterator>
    inline void destruct_impl(ForwardIterator first, ForwardIterator last, false_type) // false means the type has a significant destructor.
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;

        for(; first != last; ++first)
            (*first).~value_type();
    }

    template <typename ForwardIterator>
    inline void destruct(ForwardIterator first, ForwardIterator last)
    {
        typedef typename eastl::iterator_traits<ForwardIterator>::value_type value_type;
        destruct_impl(first, last, eastl::has_trivial_destructor<value_type>());
    }


} // namespace eastl


#ifdef _MSC_VER
    #pragma warning(pop)
#endif


#endif // Header include guard