// Copyright (C) 2006  Davis E. King (davis@dlib.net)
// License: Boost Software License   See LICENSE.txt for the full license.
#ifndef DLIB_MEMORY_MANAGER_STATELESs_1_
#define DLIB_MEMORY_MANAGER_STATELESs_1_

#include "memory_manager_stateless_kernel_abstract.h"
#include <memory>

namespace dlib
{
    template <
        typename T
        >
    class memory_manager_stateless_kernel_1
    {
        /*!      
            this implementation just calls new and delete directly
        !*/
        
        public:

            typedef T type;
            const static bool is_stateless = true;

            template <typename U>
            struct rebind {
                typedef memory_manager_stateless_kernel_1<U> other;
            };

            memory_manager_stateless_kernel_1(
            )
            {}

            virtual ~memory_manager_stateless_kernel_1(
            ) {}

            T* allocate (
            )
            {
                return new T; 
            }

            void deallocate (
                T* item
            )
            {
                delete item;
            }

            T* allocate_array (
                size_t size
            ) 
            { 
                return new T[size];
            }

            void deallocate_array (
                T* item
            ) 
            { 
                delete [] item;
            }

            void swap (memory_manager_stateless_kernel_1&)
            {}

            std::unique_ptr<T> extract(
                T* item
            )
            {
                return std::unique_ptr<T>(item);
            }

            std::unique_ptr<T[]> extract_array(
                T* item
            )
            {
                return std::unique_ptr<T[]>(item);
            }

        private:

            // restricted functions
            memory_manager_stateless_kernel_1(memory_manager_stateless_kernel_1&);        // copy constructor
            memory_manager_stateless_kernel_1& operator=(memory_manager_stateless_kernel_1&);    // assignment operator
    };

    template <
        typename T
        >
    inline void swap (
        memory_manager_stateless_kernel_1<T>& a, 
        memory_manager_stateless_kernel_1<T>& b 
    ) { a.swap(b); }   

}

#endif // DLIB_MEMORY_MANAGER_STATELESs_1_



