reallocator.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      reallocator.h
 *
 * Requires:  
 * - Mbo.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _REALLOCATOR_H_
#define _REALLOCATOR_H_

#include "Mbo.h"

#include "string.h"  /* for memmove() */
#include <new>
#include <memory>

#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4290) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
#endif

namespace mbo
{

template< class __ValueType, class __ReferenceType = __ValueType>
class allocator: public std::allocator<__ValueType>
{
public:

    typedef std::allocator<__ValueType>             __Allocator;      
    typedef typename __Allocator::size_type         size_type;        
    typedef typename __Allocator::value_type        value_type;       
    typedef typename __Allocator::pointer           pointer;          
    typedef typename __Allocator::const_pointer     const_pointer;    
    typedef typename __Allocator::difference_type   difference_type;  
    typedef __ReferenceType &        reference;        
    typedef const __ReferenceType &  const_reference;  
    pointer address(reference ref)
    {
        return &ref;
    }

    const_pointer address(const_reference ref)
    {
        return &ref;
    }

    pointer allocate(size_type size, std::allocator<void>::const_pointer hint = 0L)
    {
        return size ? reinterpret_cast<pointer>(new char [size * sizeof(value_type)]) : 0L;
    }

    void deallocate(pointer ptr, size_type size)
    {
        delete [] reinterpret_cast<char*>(ptr);
    }

    void construct(pointer ptr, const_reference oth)
    {
#if _MSC_VER >= 1300
# pragma push_macro("new")
# undef new
#endif
        new (ptr) value_type(oth);
#if _MSC_VER >= 1300
# pragma pop_macro("new")
#endif
    }

    size_type max_size() const
    {
        return static_cast<size_type>(~0) / sizeof(value_type);
    }

#if MBO_0
    allocator()
    {
    }

    template< class __Other>
    allocator(const allocator<__Other> &)
    {
    }
#endif

    template<class __Other>
    struct rebind
    {
        typedef allocator<__Other> other;
    };
};

template< class __ValueType>
class reallocator: public allocator<__ValueType>
{
public:

    pointer reallocate(pointer ptr, size_type old_size, size_type new_size) __THROWS(bad_alloc)
    {
        pointer dst = allocate(new_size);

        mbo_throw_if_not(bad_alloc, dst || !new_size);
        if (dst && ptr)
        {
            move(dst, ptr, min(new_size, old_size));
        }
        if (ptr && (dst || !new_size))
        {
            deallocate(ptr, old_size);
        }
        return dst;
    }

    void move(pointer dst, pointer src, size_type size)
    {
        //std::uninitialized_copy(src, src + size, dst);
        memmove(dst, src, size * sizeof(value_type));
    }
};

template< class __ValueType>
class mem_reallocator: public reallocator<__ValueType>
{
public:

    pointer allocate(size_type size, std::allocator<void>::const_pointer hint = 0L)
    {
        return static_cast<pointer>(mbo_malloc(size * sizeof(value_type)));
    }

    void deallocate(pointer ptr, size_type)
    {
        free(ptr);
    }

    pointer reallocate(pointer ptr, size_type, size_type new_size)
    {
        return static_cast<pointer>(mbo_realloc(ptr, new_size * sizeof(value_type)));
    }

    void move(pointer dst, pointer src, size_type size)
    {
        memmove(dst, src, size * sizeof(value_type));
    }
};

}; // namespace mbo

#if defined(_MSC_VER)
# pragma warning(pop)
#endif

#endif // _REALLOCATOR_H_

---