Span.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_SPAN_HPP
#define PLAYRHO_COMMON_SPAN_HPP
 
#include <PlayRho/Defines.hpp>
#include <PlayRho/Common/Templates.hpp>
 
#include <cstddef>
#include <cassert>
#include <type_traits>
#include <iterator>
#include <vector>
 
namespace playrho {
    
    template <typename T>
    class Span
    {
    public:
        
        using data_type = T;
 
        using pointer = data_type*;
        
        using const_pointer = const data_type *;
 
        using size_type = std::size_t;
        
        Span() = default;
        
        Span(const Span& copy) = default;
        
        PLAYRHO_CONSTEXPR inline Span(pointer array, size_type size) noexcept:
            m_array{array}, m_size{size}
        {
        }
        
        template <std::size_t SIZE>
        PLAYRHO_CONSTEXPR inline Span(data_type (&array)[SIZE]) noexcept: m_array{&array[0]}, m_size{SIZE} {}
        
        template <typename U, typename = std::enable_if_t< !std::is_array<U>::value > >
        PLAYRHO_CONSTEXPR inline Span(U& value) noexcept:
        m_array{detail::Data(value)}, m_size{detail::Size(value)} {}
        
        PLAYRHO_CONSTEXPR inline Span(std::initializer_list<T> list) noexcept:
            m_array{list.begin()}, m_size{list.size()} {}
 
        pointer begin() const noexcept { return m_array; }
 
        const_pointer cbegin() const noexcept { return m_array; }
        
        pointer end() const noexcept { return m_array + m_size; }
        
        const_pointer cend() const noexcept { return m_array + m_size; }
 
        data_type& operator[](size_type index) noexcept
        {
            assert(index < m_size);
            return m_array[index];
        }
        
        const data_type& operator[](size_type index) const noexcept
        {
            assert(index < m_size);
            return m_array[index];
        }
 
        PLAYRHO_CONSTEXPR size_type size() const noexcept { return m_size; }
        
        pointer data() const noexcept { return m_array; }
        
        PLAYRHO_CONSTEXPR bool empty() const noexcept { return m_size == 0; }
 
    private:
        pointer m_array = nullptr; 
        size_type m_size = 0; 
    };
    
} // namespace playrho
 
#endif // PLAYRHO_COMMON_SPAN_HPP