Array.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Containers/Vector.h" // SegmentObject
 
namespace SC
{
 
template <typename T, int N>
struct Array
{
    Array()
    {
        header.sizeBytes     = 0;
        header.capacityBytes = N * sizeof(T);
 
        header.isInlineBuffer           = true;
        header.isFollowedByInlineBuffer = false;
    }
 
    // clang-format off
    Array(std::initializer_list<T> list) : Array() { SC_ASSERT_RELEASE(assign({list.begin(), list.size()})); }
    ~Array() { ArraySegment().unsafeSetHeader(&header); }
    Array(const Array& other) : Array() { SC_ASSERT_RELEASE(append(other.toSpanConst())); }
    Array(Array&& other) : Array() { SC_ASSERT_RELEASE(appendMove(move(other))); }
    Array& operator=(const Array& other) { SC_ASSERT_RELEASE(assign(other.toSpanConst())); return *this; }
    Array& operator=(Array&& other) { SC_ASSERT_RELEASE(assign(move(other))); return *this; }
    template <int M>
    Array(const Array<T, M>& other) : Array() { SC_ASSERT_RELEASE(assign(other.toSpanConst()));}
    template <int M>
    Array(Array<T, M>&& other) : Array() { SC_ASSERT_RELEASE(assign(move(other))); }
    template <int M>
    Array& operator=(const Array<T, M>& other) { SC_ASSERT_RELEASE(assign(other.toSpanConst())); return *this; }
    template <int M>
    Array& operator=(Array<T, M>&& other) { SC_ASSERT_RELEASE(assign(move(other))); return *this; }
    Array(Span<const T> span) : Array() { SC_ASSERT_RELEASE(assign(span)); }
    template <typename U>
    Array(Span<const U> span) : Array() { SC_ASSERT_RELEASE(assign(span)); }
    // clang-format on
 
    [[nodiscard]] Span<const T> toSpanConst() const { return {data(), size()}; }
 
    [[nodiscard]] Span<T> toSpan() { return {data(), size()}; }
 
    [[nodiscard]] bool push_front(const T& value)
    {
        return invoke([&value](ArraySegment& segment) { return segment.push_front(value); });
    }
 
    [[nodiscard]] bool push_back(const T& value)
    {
        return invoke([&value](ArraySegment& segment) { return segment.push_back(value); });
    }
 
    [[nodiscard]] bool push_back(T&& value)
    {
        return invoke([&value](ArraySegment& segment) { return segment.push_back(move(value)); });
    }
 
    [[nodiscard]] bool pop_back(T* removedValue = nullptr)
    {
        return invoke([&](ArraySegment& segment) { return segment.pop_back(removedValue); });
    }
 
    [[nodiscard]] bool pop_front(T* removedValue = nullptr)
    {
        return invoke([&](ArraySegment& segment) { return segment.pop_front(removedValue); });
    }
 
    [[nodiscard]] bool reserve(size_t newCapacity)
    {
        return invoke([newCapacity](ArraySegment& segment) { return segment.reserve(newCapacity); });
    }
 
    [[nodiscard]] bool resize(size_t newSize, const T& value = T())
    {
        return invoke([&](ArraySegment& segment) { return segment.resize(newSize, value); });
    }
 
    [[nodiscard]] bool resizeWithoutInitializing(size_t newSize)
    {
        return invoke([&](ArraySegment& segment) { return segment.resizeWithoutInitializing(newSize); });
    }
 
    void clear()
    {
        call([](ArraySegment& segment) { return segment.clear(); });
    }
 
    [[nodiscard]] bool shrink_to_fit() { return true; }
 
    [[nodiscard]] bool insert(size_t idx, Span<const T> data)
    {
        return invoke([&](ArraySegment& segment) { return segment.insert(idx, data); });
    }
 
    [[nodiscard]] bool append(Span<const T> data)
    {
        return invoke([data](ArraySegment& segment) { return segment.append(data); });
    }
 
    [[nodiscard]] bool appendMove(Array&& other)
    {
        return invoke(
            [&other](ArraySegment& segment)
            {
                ArraySegment otherSegment;
                otherSegment.unsafeSetHeader(&other.header);
                if (not segment.appendMove(move(otherSegment)))
                {
                    otherSegment.unsafeSetHeader(nullptr);
                    return false;
                }
                return true;
            });
    }
 
    [[nodiscard]] bool assign(Span<const T> data)
    {
        return invoke([&data](ArraySegment& segment) { return segment.assign(data); });
    }
 
    template <int M>
    [[nodiscard]] bool assign(Array<T, M>&& other)
    {
        return invoke(
            [&other](ArraySegment& segment)
            {
                ArraySegment otherSegment;
                otherSegment.unsafeSetHeader(&other.unsafeGetHeader());
                if (not segment.assignMove(move(otherSegment)))
                {
                    otherSegment.unsafeSetHeader(nullptr);
                    return false;
                }
                return true;
            });
    }
 
    [[nodiscard]] bool isEmpty() const { return header.sizeBytes == 0; }
 
    [[nodiscard]] size_t size() const { return header.sizeBytes / sizeof(T); }
 
    [[nodiscard]] size_t capacity() const { return header.capacityBytes / sizeof(T); }
 
    [[nodiscard]] const T* data() const { return header.sizeBytes > 0 ? items : nullptr; }
 
    [[nodiscard]] T* data() { return header.sizeBytes > 0 ? items : nullptr; }
 
    // clang-format off
    [[nodiscard]] T*       begin() SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] const T* begin() const SC_LANGUAGE_LIFETIME_BOUND { return data(); }
    [[nodiscard]] T*       end() SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
    [[nodiscard]] const T* end() const SC_LANGUAGE_LIFETIME_BOUND { return data() + size(); }
 
    [[nodiscard]] T& back() SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] T& front() SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(not isEmpty()); return *data();}
    [[nodiscard]] T& operator[](size_t idx) SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
    [[nodiscard]] const T& back() const SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(not isEmpty()); return *(data() + size() - 1);}
    [[nodiscard]] const T& front() const SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(not isEmpty()); return *data();}
    [[nodiscard]] const T& operator[](size_t idx) const SC_LANGUAGE_LIFETIME_BOUND { SC_ASSERT_DEBUG(idx < size()); return *(data() + idx);}
    // clang-format on
 
    template <typename U>
    [[nodiscard]] bool contains(const U& value, size_t* index = nullptr) const
    {
        return toSpanConst().contains(value, index);
    }
 
    template <typename Lambda>
    [[nodiscard]] bool find(Lambda&& lambda, size_t* index = nullptr) const
    {
        return toSpanConst().find(move(lambda), index);
    }
 
    [[nodiscard]] bool removeAt(size_t index)
    {
        return invoke([=](ArraySegment& segment) { return segment.removeAt(index); });
    }
 
    template <typename Lambda>
    [[nodiscard]] bool removeAll(Lambda&& criteria)
    {
        T* itBeg = begin();
        T* itEnd = end();
        T* it    = Algorithms::removeIf(itBeg, itEnd, forward<Lambda>(criteria));
 
        const size_t numBytes = static_cast<size_t>(itEnd - it) * sizeof(T);
        const size_t offBytes = static_cast<size_t>(it - itBeg) * sizeof(T);
        ArrayVTable::destruct(header, offBytes, numBytes);
        header.sizeBytes -= static_cast<decltype(header.sizeBytes)>(numBytes);
        return it != itEnd;
    }
 
    template <typename U>
    [[nodiscard]] bool remove(const U& value)
    {
        return removeAll([&](auto& v) { return value == v; });
    }
 
    [[nodiscard]] SegmentHeader& unsafeGetHeader() { return header; }
 
  private:
    static_assert(N > 0, "Array must have N > 0");
 
    template <typename Lambda>
    auto invoke(Lambda&& lambda)
    {
        ArraySegment segment;
        segment.unsafeSetHeader(&header);
        auto res = lambda(segment);
        segment.unsafeSetHeader(nullptr);
        return res;
    }
 
    template <typename Lambda>
    auto call(Lambda&& lambda)
    {
        ArraySegment segment;
        segment.unsafeSetHeader(&header);
        lambda(segment);
        segment.unsafeSetHeader(nullptr);
    }
 
    struct ArrayVTable : public Internal::ObjectVTable<T>
    {
        static SegmentHeader* allocateNewHeader(size_t) { return nullptr; }
        static SegmentHeader* reallocateExistingHeader(SegmentHeader& src, size_t newCapacityInBytes)
        {
            return newCapacityInBytes < sizeof(items) ? &src : nullptr;
        }
        static void destroyHeader(SegmentHeader&) {}
    };
 
    using ArraySegment = Segment<ArrayVTable>;
 
    SegmentHeader header;
    union
    {
        T items[N];
    };
};
 
 
// Allows using this type across Plugin boundaries
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Array<char, 64>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Array<char, 128 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Array<char, 255 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Array<char, 512 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Array<char, 1024 * sizeof(native_char_t)>;
} // namespace SC