133 lines
4.1 KiB
C++
133 lines
4.1 KiB
C++
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* Copyright 2017-2019 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "../view.hpp"
|
|
|
|
#include "../iterator/zip.hpp"
|
|
|
|
#include <cstdlib>
|
|
#include <stdexcept>
|
|
|
|
|
|
namespace cruft {
|
|
/// An array-like object with capacity fixed at instantiation time, and a
|
|
/// size which is fixed at construction time.
|
|
///
|
|
/// \tparam S maximum number of elements
|
|
/// \tparam T data type of elements
|
|
template <std::size_t S, typename T>
|
|
class sarray {
|
|
public:
|
|
sarray (sarray &&rhs) noexcept (std::is_nothrow_move_constructible_v<T>)
|
|
: m_size (rhs.m_size)
|
|
{
|
|
for (size_t i = 0; i < m_size; ++i)
|
|
::new (&m_data.objects[i]) (T) (std::move (rhs[i]));
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
sarray (sarray const &rhs)
|
|
: sarray (cruft::view (rhs))
|
|
{ ; }
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
sarray (T const &data)
|
|
: sarray<S,T> (&data, &data + 1)
|
|
{ ; }
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
sarray (const T(&data)[S], std::size_t count = S):
|
|
sarray<S,T> (data, data + count)
|
|
{ ; }
|
|
|
|
|
|
template <typename InputIt>
|
|
sarray (InputIt first, InputIt last):
|
|
m_size (std::distance (first, last))
|
|
{
|
|
if (m_size > S)
|
|
throw std::length_error ("oversize sarray");
|
|
|
|
std::size_t i = 0;
|
|
for (auto cursor = first; cursor != last; ++cursor)
|
|
::new (&m_data.objects[i++]) (T) (*cursor);
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
template <typename ContainerT>
|
|
explicit
|
|
sarray (const ContainerT &_data):
|
|
sarray (std::begin (_data), std::end (_data))
|
|
{ ; }
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
sarray& operator= (sarray &&rhs) noexcept (std::is_nothrow_move_constructible_v<T>)
|
|
{
|
|
// Destroy the currently held objects.
|
|
for (auto &obj: *this)
|
|
obj.~T ();
|
|
|
|
// Move-construct the new objects
|
|
for (auto [idx, obj]: cruft::iterator::izip (rhs))
|
|
new (&m_data.objects[idx]) T (std::move (obj));
|
|
m_size = rhs.m_size;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
~sarray ()
|
|
{
|
|
for (std::size_t i = 0; i < m_size; ++i)
|
|
m_data.objects[i].~T ();
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
std::size_t size (void) const
|
|
{
|
|
return m_size;
|
|
}
|
|
|
|
//---------------------------------------------------------------------
|
|
T& operator[] (std::size_t i)& { return m_data.objects[i]; }
|
|
const T& operator[] (std::size_t i) const& { return m_data.objects[i]; }
|
|
|
|
auto begin (void) { return std::begin (m_data.objects); };
|
|
auto end (void) { return begin () + m_size; }
|
|
|
|
auto begin (void) const { return std::begin (m_data.objects); };
|
|
auto end (void) const { return begin () + m_size; }
|
|
|
|
auto cbegin (void) const { return std::cbegin (m_data.objects); };
|
|
auto cend (void) const { return cbegin () + m_size; }
|
|
|
|
private:
|
|
union alignas (T) data_t {
|
|
// we manually define a trivial constructor/destructor to appease
|
|
// gcc which doesn't like us using non-trivial T as the stored
|
|
// object.
|
|
//
|
|
// we're explicitly controlling the lifetime ourselves so this
|
|
// isn't a functional issue.
|
|
data_t () { };
|
|
~data_t () { };
|
|
|
|
char store[sizeof (T) * S];
|
|
T objects[S];
|
|
} m_data;
|
|
|
|
std::size_t m_size;
|
|
};
|
|
}
|