parallel_vector_tuple.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_SPACE_CORE_PARALLEL_VECTOR_TUPLE_H
#define VCL_SPACE_CORE_PARALLEL_VECTOR_TUPLE_H
 
#include <vclib/base.h>
 
#include <array>
#include <span>
 
namespace vcl {
 
template<typename... Types>
class ParallelVectorTuple
{
    using VecTuple = std::tuple<std::vector<Types>...>;
 
public:
    static constexpr uint TUPLE_SIZE = std::tuple_size_v<VecTuple>;
 
private:
    VecTuple mVecTuple;
 
    std::array<bool, TUPLE_SIZE> mVecEnabled;
    std::size_t                  mSize = 0;
 
public:
    ParallelVectorTuple()
    {
        // Initialize all vectors as enabled
        mVecEnabled.fill(true);
    }
 
    static constexpr uint tupleSize() { return TUPLE_SIZE; }
 
    std::size_t size() const { return mSize; }
 
    template<uint I>
    bool isVectorEnabled() const
    {
        static_assert(I < TUPLE_SIZE, "Index out of bounds");
        return mVecEnabled[I];
    }
 
    template<uint I>
    void enableVector()
    {
        static_assert(I < TUPLE_SIZE, "Index out of bounds");
        mVecEnabled[I] = true;
        std::get<I>(mVecTuple).resize(mSize);
    }
 
    template<uint I>
    void disableVector()
    {
        static_assert(I < TUPLE_SIZE, "Index out of bounds");
        mVecEnabled[I] = false;
        std::get<I>(mVecTuple).clear();
    }
 
    void enableAllVectors()
    {
        mVecEnabled.fill(true);
        if (mSize > 0) {
            auto func = [this](auto&& vec) {
                vec.resize(mSize);
            };
            applyToAllEnabledVectors<TUPLE_SIZE - 1>(func);
        }
    }
 
    void disableAllVectors()
    {
        mVecEnabled.fill(false);
        auto func = [](auto& vec) {
            vec.clear();
        };
        std::apply(func, mVecTuple);
        // don't change the size!
    }
 
    template<uint I>
    auto span() const
    {
        if (!isVectorEnabled<I>()) {
            throw std::runtime_error(
                "Accessing disabled vector at index " + std::to_string(I));
        }
        using RT = TypeAtT<I, Types...>;
        return std::span<const RT>(std::get<I>(mVecTuple));
    }
 
    template<uint I>
    auto span()
    {
        if (!isVectorEnabled<I>()) {
            throw std::runtime_error(
                "Accessing disabled vector at index " + std::to_string(I));
        }
        return std::span(std::get<I>(mVecTuple));
    }
 
    void resize(std::size_t size)
    {
        if constexpr (TUPLE_SIZE > 0) {
            auto func = [this, size](auto&& vec) {
                vec.resize(size);
            };
            applyToAllEnabledVectors<TUPLE_SIZE - 1>(func);
        }
        mSize = size;
    }
 
    void reserve(std::size_t size)
    {
        if constexpr (TUPLE_SIZE > 0) {
            auto func = [this, size](auto&& vec) {
                vec.reserve(size);
            };
            applyToAllEnabledVectors<TUPLE_SIZE - 1>(func);
        }
    }
 
    void clear()
    {
        if constexpr (TUPLE_SIZE > 0) {
            auto func = [](auto& vec) {
                vec.clear();
            };
            applyToAllEnabledVectors<TUPLE_SIZE - 1>(func);
        }
        mSize = 0;
    }
 
private:
    template<std::size_t N>
    void applyToAllEnabledVectors(auto&& func)
    {
        if (mVecEnabled[N]) {
            func(std::get<N>(mVecTuple));
        }
        if constexpr (N != 0)
            applyToAllEnabledVectors<N - 1>(func);
    }
};
 
template<typename... Types>
class ParallelVectorTuple<TypeWrapper<Types...>> :
        public ParallelVectorTuple<Types...>
{
};
 
} // namespace vcl
 
#endif // VCL_SPACE_CORE_PARALLEL_VECTOR_TUPLE_H