stl_alloc.hpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008-2009.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#ifndef __DERS__STL_ALLOC_HPP__
#define __DERS__STL_ALLOC_HPP__

#include <ders/config.hpp>
#include <ders/mem_pool.hpp>

namespace ders {  // ::ders

template<class T>
class stl_allocator {
      mem_pool& mp;

 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<class U> struct rebind { typedef stl_allocator<U> other; };

      stl_allocator();  // not implemented
      explicit stl_allocator(mem_pool& m) : mp(m) {}
      template<class U> stl_allocator(const stl_allocator<U>& sa) :
        mp(sa.pool()) {}

      pointer address(reference x) const { return &x; }
      const_pointer address(const_reference x) const { return &x; }
      pointer allocate(size_type n, std::allocator<void>::const_pointer = 0);
      void deallocate(pointer p, size_type n);
      size_type max_size() const throw() { return size_t(-1)/sizeof(T); }
      void construct(pointer p, const T& val) { new(p) T(val); }
      void destroy(pointer p) { p->~T(); }

      mem_pool& pool() const { return mp; }
};

template<class T>
inline typename stl_allocator<T>::pointer stl_allocator<T>::allocate(size_type
  n, std::allocator<void>::const_pointer)
{ return (n!=0) ? static_cast<pointer>(mp.allocate(n*sizeof(T))) : 0; }

template<class T>
inline void stl_allocator<T>::deallocate(pointer p, size_type n)
{ if (n!=0) mp.deallocate(p, n*sizeof(T)); }

template<class T, class U>
inline bool operator==(const stl_allocator<T>& at, const stl_allocator<U>& au)
{ return &at.pool()==&au.pool(); }

template<class T, class U>
inline bool operator!=(const stl_allocator<T>& at, const stl_allocator<U>& au)
{ return !(at==au); }

}  // namespace ::ders

#endif  // __DERS__STL_ALLOC_HPP__

---