STLMallocAllocator.h

Go to the documentation of this file.

#ifndef __LDK__STLMALLOCALLOCATOR_H__
#define __LDK__STLMALLOCALLOCATOR_H__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   This software is provided 'as-is', without any express or implied warranty.
//   In no event will the authors be held liable for any damages arising from
//   the use of this software.
//
//   Permission is granted to anyone to use this software for any purpose,
//   including commercial applications, and to alter it and redistribute it
//   freely, subject to the following restrictions:
//
//   1. The origin of this software must not be misrepresented; you must not
//   claim that you wrote the original software. If you use this software in a
//   product, an acknowledgment in the product documentation would be
//   appreciated but is not required.
//
//   2. Altered source versions must be plainly marked as such, and must not be
//   misrepresented as being the original software.
//
//   3. This notice may not be removed or altered from any source distribution.
//


#include "LDK/Exceptions.h"
#include "LDK/TemplateMeta.h"
#include <stdlib.h>
#include <assert.h>

namespace LDK
{
template<class T>
class MallocAllocator
{
public:
    typedef size_t      size_type;
    typedef ptrdiff_t   difference_type;
    typedef T*          pointer;
    typedef const T*    const_pointer;
    typedef T&          reference;
    typedef const T&    const_reference;
    typedef T           value_type;

    template<typename T1>
    struct rebind
    {
        typedef MallocAllocator<T1> other;
    };

    inline MallocAllocator() {}
    inline MallocAllocator(const MallocAllocator&) {}
    template<typename T1>
    inline MallocAllocator(const MallocAllocator<T1>&)  {}
    inline ~MallocAllocator() {}

    inline pointer address(reference r) const { return &r; }

    inline const_pointer address(const_reference r) const { return &r; }


    inline pointer allocate(size_type n, const void* = 0)
    {
       pointer ret = NULL;
       assert(n);
       ret = reinterpret_cast<pointer>(malloc(n*sizeof(value_type)));
       if(!ret)
           throw LDK_BADALLOC_ERROR;
       return ret;
    }

    //LDK extensions
    template <size_type n>
    inline pointer allocate()
    {
        pointer ret = NULL;
        CTASSERT(n>0,allocatorInvalidObjectCount);
        ret = reinterpret_cast<pointer>(malloc(n*sizeof(value_type)));
        if(!ret)
            throw LDK_BADALLOC_ERROR;
       return ret;
    }

    inline pointer reallocate(pointer mem, size_type newNo)
    {
        assert(mem);
        assert(newNo);
        return ::realloc(mem,newNo*sizeof(value_type));
    }

    //extension for the MSVC STL
    inline char* _Charalloc(size_type n, const void* = 0)
    {
        assert(n);
        char* ret = reinterpret_cast<char*>(malloc(n));
        if(!ret)
            throw LDK_BADALLOC_ERROR;
        return ret;
    }

    inline void deallocate(void* p, size_type n)
    {
        ::free(p);
    }

    inline size_type max_size() const { return size_type(-1) / sizeof(value_type); }

    inline void construct(pointer p, const value_type& val) { new(p) value_type(val); }
    inline void destroy(pointer p) { p->~T(); }
};

template<typename T1, typename T2>
inline bool operator==(const MallocAllocator<T1>&, const MallocAllocator<T2>&) { return true; }

template<typename T1, typename T2>
inline bool operator!=(const MallocAllocator<T1>&, const MallocAllocator<T2>&) { return false; }

}//namespace LDK

#endif //__LDK__STLMALLOCALLOCATOR_H__

---