/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/** 
 * @author Intel, Evgueni Brevnov
 */  
#ifndef TL_ALLOCATOR_H
#define TL_ALLOCATOR_H

#include "port_malloc.h"
#include "tl/memory_pool.h"

namespace tl
{
    /**
     * An allocator based on the basic memory allocation primitives. 
     */
    template <class T>
    class BasicAllocator
    {
    public:
        // Default constructor.
        BasicAllocator() {}

        // Copy constructor.
        template <class U> BasicAllocator(const BasicAllocator<U>& allocator) {}

        // Destructor.
        ~BasicAllocator() {}

        // Underlying pointer, reference, etc types for this allocator.
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;

        // Pointer/reference conversion.
        pointer address(reference x) const { return &x; }
        const_pointer address(const_reference x) const { return &x; }

        // Allocation/deallocation operations.
        pointer allocate(size_type n, const void* = 0)
        {
            pointer p = (pointer) STD_MALLOC(n * sizeof(T));
            LOG_ASSERT(p != NULL, "Out of memory");
            return p;
        }
                void deallocate(void * UNREF p, size_type) 
        {
            //STD_FREE(p);
        }

        // Maximum allocatable size based upon size_type.
        size_type max_size() const { return ((size_type) -1) / sizeof(value_type); }

        // Initialization/finalization operations.
        void construct(pointer p, const value_type& x) { new (p) value_type(x); }
        void destroy(pointer p) { p->~value_type(); }

        // Allocator equality tests
        template <class U>
        bool operator==(const BasicAllocator<U>& allocator) { return TRUE; }
        template <class U>
        bool operator!=(const BasicAllocator<U>& allocator) { return FALSE; }

        // Type conversion utility to obtain BasicAllocator for different underlying type.
        template <class U> struct rebind { typedef BasicAllocator<U> other; };

    };

    
    /**
     * A MemoryPool based STL allocator.                                                                     
     */
    template <class T>
    class MPAllocator 
    {
    public:
        // Standard constructor
        MPAllocator(MemoryPool& mp) : pmp(&mp) {}

        // Copy constructor.
        template <class U> MPAllocator(const MPAllocator<U>& allocator) : 
        pmp(&allocator.getMemoryPool()) {}

        // Destructor.
        ~MPAllocator() {}

        // Underlying pointer, reference, etc types for this allocator.
        typedef T* pointer;
        typedef const T* const_pointer;
        typedef T& reference;
        typedef const T& const_reference;
        typedef T value_type;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;

        // Pointer/reference conversion.
        pointer address(reference x) const { return &x; }
        const_pointer address(const_reference x) const { return &x; }

        // Underlying MemoryPool.
        MemoryPool& getMemoryPool() const { return *pmp; }

        // Allocation/deallocation operations.
        pointer allocate(size_type n, const void* = 0)
        {
            pointer p = (pointer) pmp->alloc(n * sizeof(T));
            LOG_ASSERT(p != NULL, "Out of memory");
            return p;
        }
        void deallocate(void *p, size_type) {}

        // Maximum allocatable size based upon size_type.
        size_type max_size() const { return ((size_type) -1) / sizeof(value_type); }

        // Initialization/finalization operations.
        void construct(pointer p, const value_type& x) { new (p) value_type(x); }
        void destroy(pointer p) { p->~value_type(); }

        // Allocator equality tests
        template <class U>
        bool operator==(const MPAllocator<U>& allocator) { return pmp == allocator.pmp; }
        template <class U>
        bool operator!=(const MPAllocator<U>& allocator) { return pmp != allocator.pmp; }

        // Type conversion utility to obtain MPAllocator for different underlying type.
        template <class U> struct rebind { typedef MPAllocator<U> other; };

    private:
        // Disable.  Cannot be instantiated without a MemoryPool.
        MPAllocator();

        MemoryPool* pmp;
    };

} //namespace tl

#endif // TL_ALLOCATOR_H