Allocator.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_ALLOCATOR_HXX_
#define _UTILS_ALLOCATOR_HXX_
 
#include "utils/macros.h"
 
template <typename T> class Allocator
{
public:
    union FreeList
    {
        T data; 
        FreeList *next; 
    };
 
    FreeList *freeList;
    
    bool init;
    
    size_t entries;
    
    typedef T value_type; 
    typedef value_type* pointer; 
    typedef const value_type* const_pointer; 
    typedef value_type& reference; 
    typedef const value_type& const_reference; 
    typedef std::size_t size_type; 
    typedef std::ptrdiff_t difference_type; 
    template <typename U> struct rebind
    {
        typedef Allocator<U> other;
    };
 
    explicit Allocator(size_t e)
        : freeList(NULL),
          init(false),
          entries(e)
    {
    }
 
    explicit Allocator(Allocator const& a)
        : freeList(a.freeList),
          init(a.init),
          entries(a.entries)
    {
    }
    
    ~Allocator()
    {
    }
    
    template <typename U> Allocator(Allocator<U> const& o)
        : freeList(NULL),
          init(o.init),
          entries(o.entries)
    {
    }
 
    T *address(T &r)
    {
        return &r;
    }
 
    const T *address(const T &r)
    {
        return &r;
    }
 
    T *allocate(size_t cnt, const void* = 0)
    {
        if (init == false)
        {
            HASSERT(entries != 0);
            init = true;
            FreeList *newList = (FreeList*)malloc(sizeof(FreeList) * max_size());
            for (size_t i = 0; i < max_size(); ++i)
            {
                newList[i].next = freeList;
                freeList = newList + i;
            }
        }
        HASSERT(freeList != NULL);
        HASSERT(cnt == 1);
        
        T *newT = &(freeList->data);
        freeList = freeList->next;
        return newT;
    }
    
    void deallocate(T *p, size_t n)
    {
        HASSERT(n == 1);
        FreeList *pFreeList = (FreeList*)p;
        pFreeList->next = freeList;
        freeList = pFreeList;
    }
 
    size_t max_size() const
    {
        return entries;
    }
 
    
    void construct(T *p, const T& t)
    {
        new(p) T(t);
    }
    
    void destroy(T *p)
    {
        p->~T();
    }
 
    bool operator==(Allocator const&)
    {
        return true;
    }
    
    bool operator!=(Allocator const& a)
    {
        return !operator==(a);
    }
private:
    Allocator()
        : init(false),
          entries(0)
    {
    }
};
 
#endif /* _UTILS_ALLOCATOR_HXX_ */