StaticArray.h

Go to the documentation of this file.

#pragma once
 
#include "objects/containers/ArrayView.h"
#include "objects/wrappers/AlignedStorage.h"
#include <initializer_list>
 
NAMESPACE_SPH_BEGIN
 
const struct EmptyArray {
} EMPTY_ARRAY;
 
template <typename T, int N, typename TCounter = Size>
class StaticArray {
private:
    AlignedStorage<T> data[N];
    TCounter actSize;
 
    using StorageType = WrapReference<T>;
 
public:
    StaticArray() {
        if (!std::is_trivially_default_constructible<T>::value) {
            for (TCounter i = 0; i < N; ++i) {
                data[i].emplace();
            }
        }
        actSize = N;
    }
 
    StaticArray(const EmptyArray&) {
        actSize = 0;
    }
 
    StaticArray(std::initializer_list<StorageType> list) {
        actSize = 0;
        SPH_ASSERT(list.size() <= N);
        for (auto& i : list) {
            data[actSize++].emplace(i);
        }
    }
 
    StaticArray(const StaticArray& other) = delete;
 
    StaticArray(StaticArray&& other) {
        actSize = 0;
        for (TCounter i = 0; i < other.size(); ++i) {
            // move if it contains values, just copy if it contains references
            data[actSize++].emplace(std::forward<T>(other[i]));
        }
    }
 
    ~StaticArray() {
        if (!std::is_trivially_destructible<T>::value) {
            for (TCounter i = 0; i < actSize; ++i) {
                data[i].destroy();
            }
        }
        actSize = 0;
    }
 
    StaticArray& operator=(const StaticArray& other) = delete;
 
    template <typename U, typename = std::enable_if_t<std::is_default_constructible<T>::value, U>>
    StaticArray& operator=(StaticArray<U, N>&& other) {
        this->resize(other.size());
        for (TCounter i = 0; i < other.size(); ++i) {
            // move if it contains values, just copy if it contains references
            (*this)[i] = std::forward<T>(other[i]);
        }
        return *this;
    }
 
    template <typename U, int M, typename = std::enable_if_t<std::is_lvalue_reference<T>::value, U>>
    StaticArray& operator=(StaticArray<U, M>&& other) {
        SPH_ASSERT(this->size() == other.size());
        for (TCounter i = 0; i < other.size(); ++i) {
            (*this)[i] = std::forward<U>(other[i]);
        }
        return *this;
    }
 
    StaticArray clone() const {
        StaticArray cloned(EMPTY_ARRAY);
        for (TCounter i = 0; i < actSize; ++i) {
            cloned.push(data[i].get());
        }
        return cloned;
    }
 
    void fill(const T& value) {
        for (TCounter i = 0; i < actSize; ++i) {
            data[i].get() = value;
        }
    }
 
    INLINE T& operator[](const TCounter idx) noexcept {
        SPH_ASSERT(idx >= 0 && idx < actSize, idx, actSize);
        return data[idx].get();
    }
 
    INLINE const T& operator[](const TCounter idx) const noexcept {
        SPH_ASSERT(idx >= 0 && idx < actSize, idx, actSize);
        return data[idx].get();
    }
 
    INLINE constexpr TCounter maxSize() const noexcept {
        return N;
    }
 
    INLINE TCounter size() const {
        return actSize;
    }
 
    INLINE bool empty() const {
        return actSize == 0;
    }
 
    template <typename U, typename = std::enable_if_t<std::is_constructible<StorageType, U>::value>>
    INLINE void push(U&& value) {
        SPH_ASSERT(actSize < N);
        data[actSize++].emplace(std::forward<U>(value));
    }
 
    INLINE T pop() {
        SPH_ASSERT(actSize > 0);
        T value = data[actSize - 1];
        data[actSize - 1].destroy();
        actSize--;
        return value;
    }
 
    void resize(const TCounter newSize) {
        SPH_ASSERT(unsigned(newSize) <= N);
        if (!std::is_trivially_default_constructible<T>::value) {
            if (newSize > actSize) {
                for (TCounter i = actSize; i < newSize; ++i) {
                    data[i].emplace();
                }
            } else {
                for (TCounter i = newSize; i < actSize; ++i) {
                    data[i].destroy();
                }
            }
        }
        actSize = newSize;
    }
 
    INLINE Iterator<StorageType> begin() {
        return Iterator<StorageType>(rawData(), rawData(), rawData() + actSize);
    }
 
    INLINE Iterator<const StorageType> begin() const {
        return Iterator<const StorageType>(rawData(), rawData(), rawData() + actSize);
    }
 
    INLINE Iterator<const StorageType> cbegin() const {
        return Iterator<const StorageType>(rawData(), rawData(), rawData() + actSize);
    }
 
    INLINE Iterator<StorageType> end() {
        return Iterator<StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
    }
 
    INLINE Iterator<const StorageType> end() const {
        return Iterator<const StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
    }
 
    INLINE Iterator<const StorageType> cend() const {
        return Iterator<const StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
    }
 
    operator ArrayView<T>() {
        return ArrayView<T>(rawData(), actSize);
    }
 
    operator ArrayView<const T>() const {
        return ArrayView<const T>(rawData(), actSize);
    }
 
    bool operator==(const StaticArray& other) const {
        if (actSize != other.actSize) {
            return false;
        }
        for (TCounter i = 0; i < actSize; ++i) {
            if (data[i].get() != other.data[i].get()) {
                return false;
            }
        }
        return true;
    }
 
    bool operator!=(const StaticArray& other) const {
        return !(*this == other);
    }
 
    template <typename TStream>
    friend TStream& operator<<(TStream& stream, const StaticArray& array) {
        for (const T& t : array) {
            stream << t << std::endl;
        }
        return stream;
    }
 
private:
    INLINE StorageType* rawData() {
        return reinterpret_cast<StorageType*>(data);
    }
 
    INLINE const StorageType* rawData() const {
        return reinterpret_cast<const StorageType*>(data);
    }
};
 
template <typename T0, typename... TArgs>
StaticArray<T0, sizeof...(TArgs) + 1> makeStatic(T0&& t0, TArgs&&... rest) {
    return StaticArray<T0, sizeof...(TArgs) + 1>({ std::forward<T0>(t0), std::forward<TArgs>(rest)... });
}
 
template <typename T0, typename... TArgs>
StaticArray<T0&, sizeof...(TArgs) + 1> tie(T0& t0, TArgs&... rest) {
    return StaticArray<T0&, sizeof...(TArgs) + 1>({ t0, rest... });
}
 
template <typename T>
using Pair = StaticArray<T, 2>;
 
 
template <typename T, Size N>
class ConstexprArray {
private:
    T data[N];
 
public:
    template <typename... TArgs>
    constexpr ConstexprArray(TArgs&&... args)
        : data{ std::forward<TArgs>(args)... } {}
 
    constexpr const T& operator[](const Size idx) const {
        return data[idx];
    }
 
    constexpr T& operator[](const Size idx) {
        return data[idx];
    }
};
 
NAMESPACE_SPH_END