simple_allocator.hh

Go to the documentation of this file.

/*!
 *
 * Copyright (C) 2015 Technical University of Liberec.  All rights reserved.
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 3 as published by the
 * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * 
 * @file    simple_allocator.cc
 * @ingroup system
 * @brief   Declaring internal allocator class which does not monitor memory
 *          consumption
 */


namespace internal {

    /**
     * Simple allocator which uses default malloc and free functions. Fields allocated
     *   with this allocator will not be included in overall memory consumption.
     */
    template<class T>
    class SimpleAllocator {
    public:
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;
        typedef T *pointer;
        typedef const T *const_pointer;
        typedef T &reference;
        typedef const T &const_reference;
        typedef T value_type;

        SimpleAllocator() { }

        SimpleAllocator(const SimpleAllocator &) { }


        pointer allocate(size_type n, const void * = 0) {
            T *t = (T *) malloc(n * sizeof(T));
            return t;
        }

        void deallocate(void *p, size_type) {
            if (p) {
                free(p);
            }
        }

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

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

        SimpleAllocator<T> &operator=(const SimpleAllocator &) { return *this; }

        void construct(pointer p, const T &val) { new((T *) p) T(val); }

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

        size_type max_size() const { return size_t(-1); }

        template<class U>
        struct rebind {
            typedef SimpleAllocator<U> other;
        };

        template<class U>
        SimpleAllocator(const SimpleAllocator<U> &) { }

        template<class U>
        SimpleAllocator &operator=(const SimpleAllocator<U> &) { return *this; }
    };
}