ArrayBase.hpp

Go to the documentation of this file.

// This code is based on Jet framework.
// Copyright (c) 2018 Doyub Kim
// CubbyFlow is voxel-based fluid simulation engine for computer games.
// Copyright (c) 2020 CubbyFlow Team
// Core Part: Chris Ohk, Junwoo Hwang, Jihong Sin, Seungwoo Yoo
// AI Part: Dongheon Cho, Minseo Kim
// We are making my contributions/submissions to this project solely in our
// personal capacity and are not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef CUBBYFLOW_ARRAY_BASE_HPP
#define CUBBYFLOW_ARRAY_BASE_HPP
 
#include <Core/Matrix/Matrix.hpp>
 
namespace CubbyFlow
{
template <typename T, size_t N, typename DerivedArray>
class ArrayBase
{
 public:
    using Derived = DerivedArray;
    using ValueType = T;
    using Reference = T&;
    using ConstReference = const T&;
    using Pointer = T*;
    using ConstPointer = const T*;
    using Iterator = T*;
    using ConstIterator = const T*;
 
    [[nodiscard]] size_t Index(size_t i) const;
 
    template <typename... Args>
    [[nodiscard]] size_t Index(size_t i, Args... args) const;
 
    template <size_t... I>
    [[nodiscard]] size_t Index(const Vector<size_t, N>& idx) const;
 
    [[nodiscard]] Pointer data();
 
    [[nodiscard]] ConstPointer data() const;
 
    [[nodiscard]] const Vector<size_t, N>& Size() const;
 
    template <size_t M = N>
    std::enable_if_t<(M > 0), size_t> Width() const;
 
    template <size_t M = N>
    std::enable_if_t<(M > 1), size_t> Height() const;
 
    template <size_t M = N>
    std::enable_if_t<(M > 2), size_t> Depth() const;
 
    [[nodiscard]] bool IsEmpty() const;
 
    [[nodiscard]] size_t Length() const;
 
    [[nodiscard]] Iterator begin();
 
    [[nodiscard]] ConstIterator begin() const;
 
    [[nodiscard]] Iterator end();
 
    [[nodiscard]] ConstIterator end() const;
 
    [[nodiscard]] Iterator rbegin();
 
    [[nodiscard]] ConstIterator rbegin() const;
 
    [[nodiscard]] Iterator rend();
 
    [[nodiscard]] ConstIterator rend() const;
 
    [[nodiscard]] Reference At(size_t i);
 
    [[nodiscard]] ConstReference At(size_t i) const;
 
    template <typename... Args>
    [[nodiscard]] Reference At(size_t i, Args... args);
 
    template <typename... Args>
    [[nodiscard]] ConstReference At(size_t i, Args... args) const;
 
    [[nodiscard]] Reference At(const Vector<size_t, N>& idx);
 
    [[nodiscard]] ConstReference At(const Vector<size_t, N>& idx) const;
 
    Reference operator[](size_t i);
 
    ConstReference operator[](size_t i) const;
 
    template <typename... Args>
    Reference operator()(size_t i, Args... args);
 
    template <typename... Args>
    ConstReference operator()(size_t i, Args... args) const;
 
    Reference operator()(const Vector<size_t, N>& idx);
 
    ConstReference operator()(const Vector<size_t, N>& idx) const;
 
 protected:
    ArrayBase();
 
    virtual ~ArrayBase() = default;
 
    ArrayBase(const ArrayBase& other);
 
    ArrayBase(ArrayBase&& other) noexcept;
 
    ArrayBase& operator=(const ArrayBase& other);
 
    ArrayBase& operator=(ArrayBase&& other) noexcept;
 
    template <typename... Args>
    void SetPtrAndSize(Pointer ptr, size_t ni, Args... args);
 
    void SetPtrAndSize(Pointer data, Vector<size_t, N> size);
 
    void SwapPtrAndSize(ArrayBase& other);
 
    void ClearPtrAndSize();
 
    Pointer m_ptr = nullptr;
    Vector<size_t, N> m_size;
 
 private:
    template <typename... Args>
    [[nodiscard]] size_t IndexInternal(size_t d, size_t i, Args... args) const;
 
    [[nodiscard]] size_t IndexInternal(size_t, size_t i) const;
 
    template <size_t... I>
    [[nodiscard]] size_t IndexInternal(const Vector<size_t, N>& idx,
                                       std::index_sequence<I...>) const;
};
}  // namespace CubbyFlow
 
#include <Core/Array/ArrayBase-Impl.hpp>
 
#endif