Add stack_alloc.h

Author: HowardHinnant

Diff for: stack_alloc.h

@@ -0,0 +1,94 @@
+#ifndef STACK_ALLOC_H
+#define STACK_ALLOC_H
+
+#define HAS_TYPE_TRAITS 0
+
+#include <cstddef>
+
+#if HAS_TYPE_TRAITS
+#include <type_traits>
+#else
+#include <tr1/type_traits>
+#endif
+
+template <class T, std::size_t N> class stack_alloc;
+
+template <std::size_t N>
+class stack_alloc<void, N>
+{
+public:
+    typedef const void*       const_pointer;
+    typedef void              value_type;
+};
+
+template <class T, std::size_t N>
+class stack_alloc
+{
+public:
+    typedef std::size_t       size_type;
+    typedef T                 value_type;
+    typedef value_type*       pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type&       reference;
+    typedef const value_type& const_reference;
+
+private:
+#if HAS_TYPE_TRAITS
+    typename std::aligned_storage<sizeof(T) * N, 16>::type buf_;
+#else
+    typename std::tr1::aligned_storage<sizeof(T) * N, 16>::type buf_;
+#endif
+    pointer ptr_;
+
+public:
+    stack_alloc() throw() : ptr_((pointer)&buf_) {}
+    stack_alloc(const stack_alloc&) throw() : ptr_((pointer)&buf_) {}
+    template <class U> stack_alloc(const stack_alloc<U, N>&) throw()
+         : ptr_((pointer)&buf_) {}
+
+    template <class U> struct rebind {typedef stack_alloc<U, N> other;};
+private:
+    stack_alloc& operator=(const stack_alloc&);
+public:
+    pointer allocate(size_type n, typename stack_alloc<void, N>::const_pointer = 0)
+    {
+        if ((pointer)&buf_ + N - ptr_ >= n)
+        {
+            pointer r = ptr_;
+            ptr_ += n;
+            return r;
+        }
+        return static_cast<pointer>(::operator new(n * sizeof(T)));
+    }
+    void deallocate(pointer p, size_type n)
+    {
+        if ((pointer)&buf_ <= p && p < (pointer)&buf_ + N)
+        {
+            if (p + n == ptr_)
+                ptr_ = p;
+        }
+        else
+            ::operator delete(p);
+    }
+    size_type max_size() const throw() {return size_type(~0) / sizeof(T);}
+
+    void destroy(T* p) {p->~T();}
+
+        void
+        construct(pointer p)
+        {
+            ::new((void*)p) T();
+        }
+
+    template <class A0>
+        void
+        construct(pointer p, const A0& a0)
+        {
+            ::new((void*)p) T(a0);
+        }
+
+    bool operator==(stack_alloc& a) const {return &buf_ == &a.buf_;}
+    bool operator!=(stack_alloc& a) const {return &buf_ != &a.buf_;}
+};
+
+#endif  // STACK_ALLOC_H