allocator.h

// ***********************************************************************
// Assembly         : task_scheduler
// Author           : viknash
// ***********************************************************************
// <copyright file="allocator.h" >
//     Copyright (c) viknash. All rights reserved.
// </copyright>
// <summary></summary>
// ***********************************************************************
#pragma once

namespace task_scheduler {
    template < class T, class TMemInterface > class stl_allocator : public TMemInterface
    {
    public:
        //    typedefs
        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 size_t size_type;
        typedef ptrdiff_t difference_type;

    public:
        //    convert an allocator<T> to allocator<U>

        template < typename U, class TMemInterface > struct rebind
        {
            typedef stl_allocator< U, TMemInterface > other;
        };

    public:
        inline stl_allocator() {}
        inline ~stl_allocator() {}
        inline stl_allocator(stl_allocator const &) {}
        template < typename U > inline stl_allocator(stl_allocator< U, TMemInterface > const &) {}

        inline pointer address(reference r) { return &r; }
        inline const_pointer address(const_reference r) { return &r; }

        inline pointer allocate(size_type _cnt, typename std::allocator< void >::const_pointer = 0)
        {
            pointer new_memory = reinterpret_cast<pointer>(operator new(_cnt * sizeof(T)));
            return new_memory;
        }

        inline void deallocate(pointer _p, size_type _n) { operator delete(_p, _n * sizeof(T)); }

        inline size_type max_size() const { return std::numeric_limits< size_type >::max() / sizeof(T); }

        inline bool operator==(stl_allocator const &) const { return true; }

        inline bool operator!=(stl_allocator const &_a) { return !operator==(_a); }
    };
}