Array-Impl.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_IMPL_HPP
#define CUBBYFLOW_ARRAY_IMPL_HPP

#include <Core/Utils/IterationUtils.hpp>

namespace CubbyFlow
{
template <typename T, size_t N>
class Array;

namespace Internal
{
template <typename T, size_t N, size_t I>
struct GetSizeAndInitVal
{
    template <typename... Args>
    static void Call(Vector<size_t, N>& size, T& value, size_t n, Args... args)
    {
        size[N - I - 1] = n;

        GetSizeAndInitVal<T, N, I - 1>::Call(size, value, args...);
    }
};

template <typename T, size_t N>
struct GetSizeAndInitVal<T, N, 0>
{
    static void Call(Vector<size_t, N>& size, T& value, size_t n)
    {
        Call(size, value, n, T{});
    }

    static void Call(Vector<size_t, N>& size, T& value, size_t n,
                     const T& initVal)
    {
        size[N - 1] = n;
        value = initVal;
    }
};

template <typename T, size_t N, size_t I>
struct GetSizeFromInitList
{
    static size_t Call(Vector<size_t, N>& size,
                       NestedInitializerListsT<T, I> lst)
    {
        size[I - 1] = lst.size();

        size_t i = 0;

        for (auto subLst : lst)
        {
            if (i == 0)
            {
                GetSizeFromInitList<T, N, I - 1>::Call(size, subLst);
            }
            else
            {
                Vector<size_t, N> tempSizeN;
                [[maybe_unused]] size_t otherSize =
                    GetSizeFromInitList<T, N, I - 1>::Call(tempSizeN, subLst);

                assert(otherSize == tempSizeN[I - 2]);
            }

            ++i;
        }

        return size[I - 1];
    }
};

template <typename T, size_t N>
struct GetSizeFromInitList<T, N, 1>
{
    static size_t Call(Vector<size_t, N>& size,
                       NestedInitializerListsT<T, 1> lst)
    {
        size[0] = lst.size();

        return size[0];
    }
};

template <typename T, size_t N, size_t I>
struct SetArrayFromInitList
{
    static void Call(Array<T, N>& arr, NestedInitializerListsT<T, I> lst)
    {
        size_t i = 0;

        for (auto subLst : lst)
        {
            assert(i < arr.Size()[I - 1]);

            SetArrayFromInitList<T, N, I - 1>::Call(arr, subLst, i);

            ++i;
        }
    }

    template <typename... RemainingIndices>
    static void Call(Array<T, N>& arr, NestedInitializerListsT<T, I> lst,
                     RemainingIndices... indices)
    {
        size_t i = 0;

        for (auto subLst : lst)
        {
            assert(i < arr.Size()[I - 1]);

            SetArrayFromInitList<T, N, I - 1>::Call(arr, subLst, i, indices...);
            ++i;
        }
    }
};

template <typename T, size_t N>
struct SetArrayFromInitList<T, N, 1>
{
    static void call(Array<T, N>& arr, NestedInitializerListsT<T, 1> lst)
    {
        size_t i = 0;

        for (auto val : lst)
        {
            assert(i < arr.Size()[0]);

            arr(i) = val;
            ++i;
        }
    }

    template <typename... RemainingIndices>
    static void Call(Array<T, N>& arr, NestedInitializerListsT<T, 1> lst,
                     RemainingIndices... indices)
    {
        size_t i = 0;

        for (auto val : lst)
        {
            assert(i < arr.Size()[0]);

            arr(i, indices...) = val;
            ++i;
        }
    }
};
}  // namespace Internal

template <typename T, size_t N>
Array<T, N>::Array() : Base()
{
    // Do nothing
}

template <typename T, size_t N>
Array<T, N>::Array(const Vector<size_t, N>& size_, const T& initVal) : Array()
{
    m_data.resize(Product<size_t, N>(size_, 1), initVal);
    Base::SetPtrAndSize(m_data.data(), size_);
}

template <typename T, size_t N>
template <typename... Args>
Array<T, N>::Array(size_t nx, Args... args)
{
    Vector<size_t, N> size;
    T initVal;

    Internal::GetSizeAndInitVal<T, N, N - 1>::Call(size, initVal, nx, args...);
    m_data.resize(Product<size_t, N>(size, 1), initVal);
    Base::SetPtrAndSize(m_data.data(), size);
}

template <typename T, size_t N>
Array<T, N>::Array(NestedInitializerListsT<T, N> lst)
{
    Vector<size_t, N> newSize{};

    Internal::GetSizeFromInitList<T, N, N>::Call(newSize, lst);
    m_data.resize(Product<size_t, N>(newSize, 1));
    Base::SetPtrAndSize(m_data.data(), newSize);
    Internal::SetArrayFromInitList<T, N, N>::Call(*this, lst);
}

template <typename T, size_t N>
template <typename OtherDerived>
Array<T, N>::Array(const ArrayBase<T, N, OtherDerived>& other) : Array()
{
    CopyFrom(other);
}

template <typename T, size_t N>
template <typename OtherDerived>
Array<T, N>::Array(const ArrayBase<const T, N, OtherDerived>& other) : Array()
{
    CopyFrom(other);
}

template <typename T, size_t N>
Array<T, N>::Array(const Array& other) : Array()
{
    CopyFrom(other);
}

template <typename T, size_t N>
Array<T, N>::Array(Array&& other) noexcept : Array()
{
    *this = std::move(other);
}

template <typename T, size_t N>
Array<T, N>& Array<T, N>::operator=(const Array& other)
{
    CopyFrom(other);

    return *this;
}

template <typename T, size_t N>
Array<T, N>& Array<T, N>::operator=(Array&& other) noexcept
{
    m_data = std::move(other.m_data);

    Base::SetPtrAndSize(other.data(), other.Size());
    other.SetPtrAndSize(nullptr, Vector<size_t, N>{});

    return *this;
}

template <typename T, size_t N>
template <typename OtherDerived>
Array<T, N>& Array<T, N>::operator=(const ArrayBase<T, N, OtherDerived>& other)
{
    CopyFrom(other);

    return *this;
}

template <typename T, size_t N>
template <typename OtherDerived>
Array<T, N>& Array<T, N>::operator=(
    const ArrayBase<const T, N, OtherDerived>& other)
{
    CopyFrom(other);

    return *this;
}

template <typename T, size_t N>
template <typename D>
void Array<T, N>::CopyFrom(const ArrayBase<T, N, D>& other)
{
    Resize(other.Size());
    ForEachIndex(Vector<size_t, N>{}, other.Size(),
                 [&](auto... idx) { this->At(idx...) = other(idx...); });
}

template <typename T, size_t N>
template <typename D>
void Array<T, N>::CopyFrom(const ArrayBase<const T, N, D>& other)
{
    Resize(other.Size());
    ForEachIndex(Vector<size_t, N>{}, other.Size(),
                 [&](auto... idx) { this->At(idx...) = other(idx...); });
}

template <typename T, size_t N>
void Array<T, N>::Fill(const T& val)
{
    std::fill(m_data.begin(), m_data.end(), val);
}

template <typename T, size_t N>
void Array<T, N>::Resize(Vector<size_t, N> size_, const T& initVal)
{
    Array newArray(size_, initVal);
    Vector<size_t, N> minSize = Min(m_size, newArray.m_size);

    ForEachIndex(minSize,
                 [&](auto... idx) { newArray(idx...) = (*this)(idx...); });

    *this = std::move(newArray);
}

template <typename T, size_t N>
template <typename... Args>
void Array<T, N>::Resize(size_t nx, Args... args)
{
    Vector<size_t, N> size;
    T initVal;

    Internal::GetSizeAndInitVal<T, N, N - 1>::Call(size, initVal, nx, args...);

    Resize(size, initVal);
}

template <typename T, size_t N>
template <size_t M>
std::enable_if_t<(M == 1), void> Array<T, N>::Append(const T& val)
{
    m_data.push_back(val);

    Base::SetPtrAndSize(m_data.data(), m_data.size());
}

template <typename T, size_t N>
template <typename OtherDerived, size_t M>
std::enable_if_t<(M == 1), void> Array<T, N>::Append(
    const ArrayBase<T, N, OtherDerived>& extra)
{
    m_data.insert(m_data.end(), extra.begin(), extra.end());

    Base::SetPtrAndSize(m_data.data(), m_data.size());
}

template <typename T, size_t N>
template <typename OtherDerived, size_t M>
std::enable_if_t<(M == 1), void> Array<T, N>::Append(
    const ArrayBase<const T, N, OtherDerived>& extra)
{
    m_data.insert(m_data.end(), extra.begin(), extra.end());

    Base::SetPtrAndSize(m_data.data(), m_data.size());
}

template <typename T, size_t N>
void Array<T, N>::Clear()
{
    Base::ClearPtrAndSize();

    m_data.clear();
}

template <typename T, size_t N>
void Array<T, N>::Swap(Array& other)
{
    Base::SwapPtrAndSize(other);

    std::swap(m_data, other.m_data);
}

template <typename T, size_t N>
ArrayView<T, N> Array<T, N>::View()
{
    return ArrayView<T, N>(*this);
}

template <typename T, size_t N>
ArrayView<const T, N> Array<T, N>::View() const
{
    return ArrayView<const T, N>(*this);
}
}  // namespace CubbyFlow

#endif