#ifndef __SHM_ALLOCATOR_H__
#define __SHM_ALLOCATOR_H__
#include "usg_common.h"
#include "mm.h"
#include <new>
#include <cstdlib> // for exit()
#include <climits> // for UNIX_MAX
#include <cstddef>



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


  SHMAllocator() {};
  ~SHMAllocator() {};
  template<class U> SHMAllocator(const SHMAllocator<U>& t) { };
  template<class U> struct rebind { typedef SHMAllocator<U> other; };

  pointer allocate(size_type n, const void* hint=0) {
//        fprintf(stderr, "allocate n=%u, hint= %p\n",n, hint);
    return((T*) (mm_malloc(n * sizeof(T))));
  }

  void deallocate(pointer p, size_type n) {
//        fprintf(stderr, "dealocate n=%u" ,n);
    mm_free((void*)p);
  }

  void construct(pointer p, const T& value) {
    ::new(p) T(value);
  }

  void construct(pointer p)
  {
    ::new(p) T();
  }

  void destroy(pointer p) {
    p->~T();
  }

  pointer address(reference x) {
    return (pointer)&x;
  }

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

  size_type max_size() const {
    return size_type(UINT_MAX/sizeof(T));
  }
};


// template<class charT, class traits = char _traits<charT>,
// class Allocator = allocator<charT> >  




typedef std::basic_string<char, std::char_traits<char>, SHMAllocator<char> > shmstring;

#endif