AllocatedArray.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Louis Langholtz https://github.com/louis-langholtz/PlayRho
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
#ifndef PLAYRHO_COMMON_ALLOCATEDARRAY_HPP
#define PLAYRHO_COMMON_ALLOCATEDARRAY_HPP
 
#include <PlayRho/Common/Settings.hpp>
 
#include <functional>
 
namespace playrho {
 
template <typename T, typename Deleter = std::function<void (void *)> >
class AllocatedArray
{
public:
    
    using size_type = std::size_t;
 
    using value_type = T;
    
    using const_value_type = const value_type;
    
    using reference = value_type&;
    
    using const_reference = const value_type&;
    
    using pointer = value_type*;
    
    using const_pointer = const value_type*;
    
    using difference_type = std::ptrdiff_t;
    
    using deleter_type = Deleter;
 
    using iterator = pointer;
 
    using const_iterator = const_pointer;
 
    PLAYRHO_CONSTEXPR inline AllocatedArray(size_type max_size, pointer data, deleter_type deleter = noop_deleter):
        m_max_size{max_size}, m_data{data}, m_deleter{deleter}
    {
        assert(data);
    }
    
    ~AllocatedArray() noexcept
    {
        m_deleter(m_data);
        m_data = nullptr;
    }
 
    AllocatedArray() = delete;
    AllocatedArray(const AllocatedArray& copy) = delete;
 
    AllocatedArray(AllocatedArray&& other) noexcept:
        m_max_size{other.m_max_size}, m_size{other.m_size}, m_data{other.m_data}, m_deleter{other.m_deleter}
    {
        other.m_size = 0;
        other.m_data = nullptr;
    }
 
    size_type size() const noexcept { return m_size; }
 
    size_type max_size() const noexcept { return m_max_size; }
    
    bool empty() const noexcept { return size() == 0; }
 
    pointer data() const noexcept { return m_data; }
 
    reference operator[](size_type i)
    {
        assert(i < m_size);
        return m_data[i];
    }
 
    const_reference operator[](size_type i) const
    {
        assert(i < m_size);
        return m_data[i];
    }
 
    iterator begin() { return iterator{m_data}; }
 
    iterator end() { return iterator{m_data + size()}; }
    
    const_iterator begin() const { return const_iterator{m_data}; }
    
    const_iterator end() const { return const_iterator{m_data + size()}; }
    
    const_iterator cbegin() const { return const_iterator{m_data}; }
    
    const_iterator cend() const { return const_iterator{m_data + size()}; }
 
    reference back() noexcept
    {
        assert(m_size > 0);
        return m_data[m_size - 1];        
    }
 
    const_reference back() const noexcept
    {
        assert(m_size > 0);
        return m_data[m_size - 1];
    }
 
    void clear() noexcept
    {
        m_size = 0;
    }
 
    void push_back(const_reference value)
    {
        assert(m_size < m_max_size);
        m_data[m_size] = value;
        ++m_size;
    }
    
    void pop_back() noexcept
    {
        assert(m_size > 0);
        --m_size;
    }
 
private:
    
    static void noop_deleter(void* /*unused*/) {}
 
    size_type m_max_size = 0; 
    size_type m_size = 0; 
    pointer m_data = nullptr; 
    deleter_type m_deleter; 
};
 
}; // namespace playrho
 
#endif // PLAYRHO_COMMON_ALLOCATEDARRAY_HPP