mgl_array.h

[詳解]

// SPDX-License-Identifier: Zlib
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
 
#ifndef INCGUARD_MGL_ARRAY_H_1744450834
#define INCGUARD_MGL_ARRAY_H_1744450834
 
#include <memory>
#include <type_traits>
#include <utility>
 
#include <mgl/common/mgl_range.h>
#include <mgl/memory/mgl_memory.h>
#include <mgl/memory/mgl_memory_utility.h>
#include <mgl/system/mgl_system_debug_macro.h>
 
namespace MGL
{
/* ------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------- */
template <class ValueType, class IndexType = size_t>
class Array
{
public:
    // 配列の要素はデフォルト構築可能でなければならない
    static_assert(std::is_default_constructible_v<ValueType>, "Array element must be constructible by default.");
 
    // インデックスは整数型である必要がある
    static_assert(std::is_integral_v<IndexType>, "IndexType must be integral value.");
 
    // コピーは禁止
    Array(Array &) = delete;
    Array &operator=(Array &) = delete;
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    explicit Array(size_t arraySize = 0, Memory::ClearMode clearMode = Memory::ClearMode::Auto) noexcept
    {
        Allocate(arraySize, clearMode);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    Array(size_t arraySize, const ValueType &invalidValue, Memory::ClearMode clearMode = Memory::ClearMode::Auto) noexcept
    {
        Allocate(arraySize, clearMode);
        SetInvalidValue(invalidValue);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    Array(size_t arraySize, ValueType &&invalidValue, Memory::ClearMode clearMode = Memory::ClearMode::Auto) noexcept
    {
        Allocate(arraySize, clearMode);
        SetInvalidValue(std::move(invalidValue));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    Array(Array &&rhs) noexcept
    {
        *this = std::move(rhs);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    Array &operator=(Array &&rhs) noexcept
    {
        Deallocate();
 
        // NOLINTBEGIN(cppcoreguidelines-prefer-member-initializer) : 上のDeallocate()が呼べなくなるので無理
        _arraySize = rhs._arraySize;
        _top = rhs._top;
        _tail = rhs._tail;
        // NOLINTEND(cppcoreguidelines-prefer-member-initializer)
 
        rhs._arraySize = 0;
        rhs._top = nullptr;
        rhs._tail = nullptr;
 
        return *this;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    ~Array() noexcept
    {
        Deallocate();
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool New(size_t arraySize, Memory::ClearMode clearMode = Memory::ClearMode::Auto) noexcept
    {
        // 末尾（無効値）が存在している場合はそれを保つように生成
        if (_tail != nullptr)
        {
            auto invalidValue = std::move(*_tail);    // アロケート中に消えるので別のメモリ空間に移動しておく
            if (Allocate(arraySize, clearMode))
            {
                SetInvalidValue(invalidValue);
                return true;
            }
            return false;
        }
        // 末尾が存在していない場合は普通に生成
        else
        {
            // Note: 実はここには到達しない（コンストラクタがアロケートして無効値も生成されるため）
            return Allocate(arraySize, clearMode);
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool Renew(Memory::ClearMode clearMode = Memory::ClearMode::Auto) noexcept
    {
        return New(_arraySize, clearMode);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void Fill(const ValueType &value) noexcept
    {
        for (auto *e = begin(); e != end(); e++)
        {
            *e = value;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const ValueType &Get(IndexType index) const noexcept
    {
        return _top[GetIndex(index)];
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const ValueType &operator[](IndexType index) const noexcept
    {
        return Get(index);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr ValueType *GetPtr(IndexType index) noexcept
    {
        if (auto i = GetIndex(index); i < _arraySize)
        {
            return std::addressof(_top[i]);
        }
 
        return nullptr;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr void ForEach(LoopBody body) noexcept
    {
        for (size_t i = 0; i < _arraySize; i++)
        {
            if (!InvokeLoopBody(body, static_cast<IndexType>(i)))
            {
                return;
            }
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr void ForEach(LoopBody body) const noexcept
    {
        for (size_t i = 0; i < _arraySize; i++)
        {
            if (!InvokeLoopBody(body, static_cast<IndexType>(i)))
            {
                return;
            }
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr void ForRange(IndexType begin, IndexType end, LoopBody body) noexcept
    {
        if (_arraySize == 0)
        {
            return;
        }
 
        Range<IndexType> range(
            std::clamp(begin, static_cast<IndexType>(0), static_cast<IndexType>(_arraySize) - 1),
            std::clamp(end, static_cast<IndexType>(0), static_cast<IndexType>(_arraySize) - 1));
 
        for (auto i = range.Begin(); range.Contains(i); i = range.Next(i))
        {
            if (!InvokeLoopBody(body, i))
            {
                return;
            }
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr void ForRange(IndexType begin, IndexType end, LoopBody body) const noexcept
    {
        if (_arraySize == 0)
        {
            return;
        }
 
        Range<IndexType> range(
            std::clamp(begin, 0, static_cast<IndexType>(_arraySize) - 1),
            std::clamp(end, 0, static_cast<IndexType>(_arraySize) - 1));
 
        for (auto i = range.Begin(); range.Contains(i); i = range.Next(i))
        {
            if (!InvokeLoopBody(body, i))
            {
                return;
            }
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool Contains(const ValueType &element) const noexcept
    {
        return Contains(std::addressof(element));
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr bool Contains(const ValueType *element) const noexcept
    {
        // Note:
        // ValueType型の実体をを内包するValueType型は作れないはずなので、
        // 各要素のアドレスと一致するかのチェックは不要なはず。
 
        auto topAddress = reinterpret_cast<uintptr_t>(_top);
        auto elemAddress = reinterpret_cast<uintptr_t>(element);
        auto tailAddress = reinterpret_cast<uintptr_t>(_tail);
 
        return (topAddress <= elemAddress) && (elemAddress < tailAddress);
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetInvalidValue(const ValueType &value) noexcept
    {
        if (_tail != nullptr)
        {
            *_tail = value;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    constexpr void SetInvalidValue(ValueType &&value) noexcept
    {
        if (_tail != nullptr)
        {
            *_tail = std::move(value);
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr size_t GetSize() const noexcept
    {
        return _arraySize;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr ValueType *begin() const noexcept
    {
        return _top;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr ValueType *end() const noexcept
    {
        return _tail;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const ValueType *cbegin() const noexcept
    {
        return _top;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr const ValueType *cend() const noexcept
    {
        return _tail;
    }
 
private:
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    bool Allocate(size_t arraySize, Memory::ClearMode clearMode) noexcept
    {
        // 生成済みかつ同サイズであればアロケートを省略
        if ((_top != nullptr) && (_arraySize == arraySize))
        {
            // 全てのデストラクタを呼び出す
            std::destroy_n(_top, _arraySize + 1);
 
            // メモリ領域をクリア
            _top = Memory::Utility::InitializeArrayBuffer<ValueType>(_top, _arraySize + 1, clearMode);
        }
        // 未生成、またはサイズが異なる場合は一旦削除して際生成
        else
        {
            // 一旦削除
            Deallocate();
 
            // アロケータからメモリを確保
            const auto size = sizeof(ValueType) * (arraySize + 1);
            auto *ptr = Memory::Allocate(size);
            MGL_ASSERT(ptr, "Memory allocation failed.");
            if (ptr == nullptr)
            {
                return false;
            }
 
            // メモリ領域をクリア
            _top = Memory::Utility::InitializeArrayBuffer<ValueType>(ptr, arraySize + 1, clearMode);
 
            // 確保したメモリリソースをもとに各メンバを初期化
            _tail = std::addressof(_top[arraySize]);
            _arraySize = arraySize;
        }
 
        return true;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    void Deallocate() noexcept
    {
        if (_top != nullptr)
        {
            std::destroy_n(_top, _arraySize + 1);
            Memory::Deallocate(_top);
            _top = _tail = nullptr;
            _arraySize = 0;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    [[nodiscard]] constexpr size_t GetIndex(IndexType index) const noexcept
    {
        // 符号付きの場合は負数もチェックする
        if constexpr (std::is_signed_v<IndexType>)
        {
            if ((index >= 0) && (static_cast<size_t>(index) < _arraySize))
            {
                return static_cast<size_t>(index);
            }
        }
        // 符号なしの場合はインデックス以下であるかどうかのみ
        else
        {
            if (static_cast<size_t>(index) < _arraySize)
            {
                return static_cast<size_t>(index);
            }
        }
 
        // 範囲外の場合は末尾のインデックスを返す
        return _arraySize;
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr bool InvokeLoopBody(LoopBody body, IndexType index) noexcept
    {
        // インデックス付き、中断あり
        if constexpr (std::is_invocable_r_v<bool, decltype(body), IndexType, ValueType &>)
        {
            return body(index, _top[GetIndex(index)]);
        }
        // インデックス付き、中断なし
        else if constexpr (std::is_invocable_r_v<void, decltype(body), IndexType, ValueType &>)
        {
            body(index, _top[GetIndex(index)]);
            return true;
        }
        // インデックスなし、中断あり
        else if constexpr (std::is_invocable_r_v<bool, decltype(body), ValueType &>)
        {
            return body(_top[GetIndex(index)]);
        }
        // インデックスなし、中断なし
        else if constexpr (std::is_invocable_r_v<void, decltype(body), ValueType &>)
        {
            body(_top[GetIndex(index)]);
            return true;
        }
        // それ以外は不適格
        else
        {
            static_assert(std::false_type::value, "Loop body is not matching arguments.");
            return false;
        }
    }
 
    /* ------------------------------------------------------------------------- */
    /* ------------------------------------------------------------------------- */
    template <class LoopBody>
    constexpr bool InvokeLoopBody(LoopBody body, IndexType index) const noexcept
    {
        // インデックス付き、中断あり
        if constexpr (std::is_invocable_r_v<bool, decltype(body), IndexType, ValueType &>)
        {
            return body(index, _top[GetIndex(index)]);
        }
        // インデックス付き、中断なし
        else if constexpr (std::is_invocable_r_v<void, decltype(body), IndexType, ValueType &>)
        {
            body(index, _top[GetIndex(index)]);
            return true;
        }
        // インデックスなし、中断あり
        else if constexpr (std::is_invocable_r_v<bool, decltype(body), ValueType &>)
        {
            return body(_top[GetIndex(index)]);
        }
        // インデックスなし、中断なし
        else if constexpr (std::is_invocable_r_v<void, decltype(body), ValueType &>)
        {
            body(_top[GetIndex(index)]);
            return true;
        }
        // それ以外は不適格
        else
        {
            static_assert(std::false_type::value, "Loop body is not matching arguments.");
            return false;
        }
    }
 
    size_t _arraySize{0};
    ValueType *_top{nullptr};
    ValueType *_tail{nullptr};
};
}    // namespace MGL
 
#endif    // INCGUARD_MGL_ARRAY_H_1744450834
 
// vim: et ts=4 sw=4 sts=4