STLAllocator.h

Go to the documentation of this file.

#ifndef __LDK_STLALLOCATOR_H__
#define __LDK_STLALLOCATOR_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.
//


namespace LDK
{
template<class T>
class Allocator
{
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 Allocator<T1> other;
    };

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

    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)
    {
       assert(n);
       return reinterpret_cast<pointer>(LDK_RTALLOC(n*sizeof(value_type)));
    }

    //LDK extensions
    template <size_type n>
    inline pointer allocate()
    {
        CTASSERT(n>0,allocatorInvalidObjectCount);
        return reinterpret_cast<pointer>(LDK_CTALLOC(n*sizeof(value_type)));
    }

    inline pointer reallocate(pointer mem, size_type newNo)
    {
        assert(mem);
        assert(newNo);
        return reinterpret_cast<pointer>(LDK_REALLOC(mem,newNo*sizeof(value_type)));
    }

    //extension for the MSVC STL
    inline char* _Charalloc(size_type n, const void* = 0)
    {
        assert(n);
        return reinterpret_cast<char*>(LDK_RTALLOC(n));
    }

    inline void deallocate(void* p, size_type n)
    {
        LDK::dealloc(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 Allocator<T1>&, const Allocator<T2>&) { return true; }

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

}//namespace LDK

#endif //__LDK_STLALLOCATOR_H__

---