element_container.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_MESH_CONTAINERS_BASE_ELEMENT_CONTAINER_H
#define VCL_MESH_CONTAINERS_BASE_ELEMENT_CONTAINER_H
 
#include "base.h"
#include "custom_component_vector_handle.h"
 
#include "../detail/custom_components_vector_map.h"
#include "../detail/vertical_components_vector_tuple.h"
 
#include <vclib/mesh/components/base/component.h>
#include <vclib/mesh/components/custom_components.h>
#include <vclib/mesh/elements/base/element.h>
#include <vclib/mesh/iterators/element_container_iterator.h>
 
#include <vclib/base.h>
 
#include <vector>
 
namespace vcl::mesh {
 
template<ElementConcept T>
class ElementContainer : public ElementContainerTriggerer
{
    template<ElementConcept U>
    friend class ElementContainer;
 
    using ElementContainerType = ElementContainer<T>;
 
    // filter components of elements, taking only vertical ones
    using VertComps = FilterTypesByCondition<
        comp::IsVerticalComponentPred,
        typename T::Components>::type;
 
public:
    using ElementType    = T;
    using ParentMeshType = T::ParentMeshType;
 
protected:
    ParentMeshType* mParentMesh = nullptr;
 
    uint mElemNumber = 0;
 
    std::vector<T> mElemVec;
 
    detail::VerticalComponentsVectorTuple<VertComps> mVerticalCompVecTuple;
 
    detail::CustomComponentsVectorMap<comp::HasCustomComponents<T>>
        mCustomCompVecMap;
 
public:
    static const uint ELEMENT_ID = T::ELEMENT_ID;
 
    ElementContainer() = default;
 
protected:
    /* Members that are directly inherited by Containers (just renaming them) */
    using ElementIterator      = ElementContainerIterator<std::vector, T>;
    using ConstElementIterator = ConstElementContainerIterator<std::vector, T>;
 
    const T& element(uint i) const
    {
        assert(i < mElemVec.size());
        return mElemVec[i];
    }
 
    T& element(uint i)
    {
        assert(i < mElemVec.size());
        return mElemVec[i];
    }
 
    uint elementNumber() const { return mElemNumber; }
 
    uint elementContainerSize() const { return mElemVec.size(); }
 
    uint deletedElementNumber() const
    {
        return elementContainerSize() - elementNumber();
    }
 
    uint addElement()
    {
        mVerticalCompVecTuple.resize(mElemVec.size() + 1);
        if constexpr (comp::HasCustomComponents<T>)
            mCustomCompVecMap.resize(mElemVec.size() + 1);
 
        T* oldB = mElemVec.data();
        mElemVec.emplace_back();
        T* newB = mElemVec.data();
        mElemNumber++;
 
        mElemVec.back().setParentMesh(mParentMesh);
        mElemVec.back().initVerticalComponents();
 
        if (oldB != newB) {
            setParentMeshPointers(mParentMesh);
            mParentMesh->updateAllReferences(oldB);
        }
 
        return mElemVec.size() - 1;
    }
 
    uint addElements(uint size)
    {
        mVerticalCompVecTuple.resize(mElemVec.size() + size);
        if constexpr (comp::HasCustomComponents<T>)
            mCustomCompVecMap.resize(mElemVec.size() + size);
 
        uint baseId = mElemVec.size();
        T*   oldB   = mElemVec.data();
        mElemVec.resize(mElemVec.size() + size);
        T* newB = mElemVec.data();
        mElemNumber += size;
 
        for (uint i = baseId; i < mElemVec.size(); ++i) {
            mElemVec[i].setParentMesh(mParentMesh);
            mElemVec[i].initVerticalComponents();
        }
 
        if (oldB != newB) {
            setParentMeshPointers(mParentMesh);
            mParentMesh->updateAllReferences(oldB);
        }
 
        return baseId;
    }
 
    void clearElements()
    {
        mElemVec.clear();
        mElemNumber = 0;
 
        // clear vertical and custom components
 
        mVerticalCompVecTuple.clear();
        if constexpr (comp::HasCustomComponents<T>)
            mCustomCompVecMap.clear();
    }
 
    void resizeElements(uint size)
    {
        if (size > mElemNumber) {
            addElements(size - mElemNumber);
        }
        else if (size < mElemNumber) {
            uint nToDelete = mElemNumber - size;
            for (uint i = mElemVec.size() - 1; nToDelete > 0; --i) {
                if (!mElemVec[i].deleted()) {
                    deleteElement(i);
                }
            }
        }
    }
 
    void reserveElements(uint size)
    {
        T* oldB = mElemVec.data();
        mElemVec.reserve(size);
        T* newB = mElemVec.data();
 
        mVerticalCompVecTuple.reserve(size);
        if constexpr (comp::HasCustomComponents<T>)
            mCustomCompVecMap.reserve(size);
 
        if (oldB != newB) {
            setParentMeshPointers(mParentMesh);
            mParentMesh->updateAllReferences(oldB);
        }
    }
 
    std::vector<uint> compactElements()
    {
        std::vector<uint> newIndices = elementCompactIndices();
        if (elementNumber() != elementContainerSize()) {
            compactVector(mElemVec, newIndices);
 
            mVerticalCompVecTuple.compact(newIndices);
            if constexpr (comp::HasCustomComponents<T>)
                mCustomCompVecMap.compact(newIndices);
 
            updateElementIndices(newIndices);
        }
        return newIndices;
    }
 
    void deleteElement(uint i)
    {
        assert(i < mElemVec.size());
        mElemVec[i].deletedBit() = true;
        --mElemNumber;
    }
 
    void deleteElement(const T* e) { deleteElement(index(e)); }
 
    uint elementIndexIfCompact(uint i) const
    {
        assert(i < mElemVec.size());
        if (mElemVec.size() == mElemNumber)
            return i;
        else {
            uint cnt = 0;
            for (uint ii = 0; ii < i; ii++) {
                if (!mElemVec[ii].deleted())
                    ++cnt;
            }
            return cnt;
        }
    }
 
    std::vector<uint> elementCompactIndices() const
    {
        std::vector<uint> newIndices(mElemVec.size());
        uint              k = 0;
        for (uint i = 0; i < mElemVec.size(); ++i) {
            if (!mElemVec[i].deleted()) {
                newIndices[i] = k;
                k++;
            }
            else {
                newIndices[i] = UINT_NULL;
            }
        }
        return newIndices;
    }
 
    void append(const ElementContainer<T>& other)
    {
        using Comps = T::Components;
 
        uint on = other.elementContainerSize();
        uint n  = elementContainerSize();
        addElements(on);
        for (uint i = 0; i < on; ++i) {
            // copy everything from the other elements, also the (not updated)
            // pointers:
            if (other.element(i).deleted()) {
                deleteElement(n + i);
            }
            element(n + i) = other.element(i);
            element(n + i).setParentMesh(mParentMesh);
        }
        // importing also optional, vertical and custom components:
        appendVerticalComponents(other, VertComps());
        appendCustomComponents(other);
    }
 
    void serializeOptionalComponentsAndElementsNumber(std::ostream& out) const
    {
        constexpr uint                 N_VERT_COMPS = VertComps::size();
        std::array<bool, N_VERT_COMPS> enabledComps;
        uint                           i = 0;
 
        auto forEachVertComp = [&]<typename Comp>() {
            enabledComps[i] =
                mVerticalCompVecTuple.template isComponentEnabled<Comp>();
            ++i;
        };
 
        ForEachType<VertComps>::apply(forEachVertComp);
 
        vcl::serialize(out, elementContainerSize());
        vcl::serialize(out, enabledComps);
    }
 
    void serializeElements(std::ostream& out) const
    {
        for (const auto& e : mElemVec) {
            e.serialize(out);
        }
    }
 
    void deserializeOptionalComponentsAndElementsNumber(std::istream& in)
    {
        constexpr uint                 N_VERT_COMPS = VertComps::size();
        std::array<bool, N_VERT_COMPS> enabledComps;
        uint                           size = 0;
 
        vcl::deserialize(in, size);
        vcl::deserialize(in, enabledComps);
 
        resizeElements(size);
 
        uint i               = 0;
        auto forEachVertComp = [&]<typename Comp>() {
            if (enabledComps[i])
                mVerticalCompVecTuple.template enableComponent<Comp>();
            else
                mVerticalCompVecTuple.template disableComponent<Comp>();
            ++i;
        };
 
        ForEachType<VertComps>::apply(forEachVertComp);
    }
 
    void deserializeElements(std::istream& in)
    {
        for (auto& e : mElemVec) {
            e.deserialize(in);
        }
    }
 
    ElementIterator elementBegin(bool jumpDeleted = true)
    {
        return ElementIterator(
            mElemVec.begin(),
            mElemVec,
            jumpDeleted && mElemVec.size() != mElemNumber);
    }
 
    ElementIterator elementEnd()
    {
        return ElementIterator(mElemVec.end(), mElemVec);
    }
 
    ConstElementIterator elementBegin(bool jumpDeleted = true) const
    {
        return ConstElementIterator(
            mElemVec.begin(),
            mElemVec,
            jumpDeleted && mElemVec.size() != mElemNumber);
    }
 
    ConstElementIterator elementEnd() const
    {
        return ConstElementIterator(mElemVec.end(), mElemVec);
    }
 
    View<ElementIterator> elements(bool jumpDeleted = true)
    {
        return View(
            elementBegin(jumpDeleted && mElemVec.size() != mElemNumber),
            elementEnd());
    }
 
    View<ElementIterator> elements(uint begin, uint end = UINT_NULL)
    {
        assert(begin <= elementContainerSize());
        if (end == UINT_NULL || end > elementContainerSize())
            end = elementContainerSize();
        assert(begin <= end);
        return View(elementBegin(false) + begin, elementBegin(false) + end);
    }
 
    View<ConstElementIterator> elements(bool jumpDeleted = true) const
    {
        return View(
            elementBegin(jumpDeleted && mElemVec.size() != mElemNumber),
            elementEnd());
    }
 
    View<ConstElementIterator> elements(uint begin, uint end = UINT_NULL) const
    {
        assert(begin <= elementContainerSize());
        if (end == UINT_NULL || end > elementContainerSize())
            end = elementContainerSize();
        assert(begin <= end);
        return View(elementBegin(false) + begin, elementBegin(false) + end);
    }
 
    void enableAllOptionalComponents()
    {
        mVerticalCompVecTuple.enableAllOptionalComponents();
    }
 
    void disableAllOptionalComponents()
    {
        mVerticalCompVecTuple.disableAllOptionalComponents();
    }
 
    template<typename C>
    bool isComponentAvailable() const
    {
        if constexpr (comp::HasComponentOfType<T, C::COMPONENT_ID>) {
            if constexpr (comp::
                              HasOptionalComponentOfType<T, C::COMPONENT_ID>) {
                return mVerticalCompVecTuple.template isComponentEnabled<C>();
            }
            else {
                return true;
            }
        }
        else {
            return false;
        }
    }
 
    template<uint COMP_ID>
    bool isComponentAvailable() const
    {
        if constexpr (comp::HasComponentOfType<T, COMP_ID>) {
            if constexpr (comp::HasOptionalComponentOfType<T, COMP_ID>) {
                return mVerticalCompVecTuple
                    .template isComponentEnabled<COMP_ID>();
            }
            else {
                return true;
            }
        }
        else {
            return false;
        }
    }
 
    template<typename C>
    bool isOptionalComponentEnabled() const
    {
        return mVerticalCompVecTuple.template isComponentEnabled<C>();
    }
 
    template<uint COMP_ID>
    bool isOptionalComponentEnabled() const
    {
        return mVerticalCompVecTuple.template isComponentEnabled<COMP_ID>();
    }
 
    template<typename C>
    void enableOptionalComponent()
    {
        mVerticalCompVecTuple.template enableComponent<C>();
        // first call init on all the just enabled components
        if constexpr (comp::HasInitMemberFunction<C>) {
            for (auto& e : elements()) {
                e.C::init();
            }
        }
        // then resize the component containers with tied size to vertex number
        if constexpr (comp::IsTiedToVertexNumber<C>) {
            static const int N = T::VERTEX_NUMBER;
            if constexpr (N < 0) {
                for (auto& e : elements()) {
                    e.C::resize(e.vertexNumber());
                }
            }
        }
    }
 
    template<uint COMP_ID>
    void enableOptionalComponent()
    {
        using C = comp::ComponentOfType<COMP_ID, typename T::Components>;
        enableOptionalComponent<C>();
    }
 
    template<typename C>
    void disableOptionalComponent()
    {
        mVerticalCompVecTuple.template disableComponent<C>();
    }
 
    template<uint COMP_ID>
    void disableOptionalComponent()
    {
        mVerticalCompVecTuple.template disableComponent<COMP_ID>();
    }
 
    // Custom Components
 
    bool hasElemCustomComponent(const std::string& name) const
        requires comp::HasCustomComponents<T>
    {
        return mCustomCompVecMap.componentExists(name);
    }
 
    std::vector<std::string> elemCustomComponentNames() const
        requires comp::HasCustomComponents<T>
    {
        return mCustomCompVecMap.allComponentNames();
    }
 
    template<typename K>
    bool isElemCustomComponentOfType(const std::string& name) const
        requires comp::HasCustomComponents<T>
    {
        return mCustomCompVecMap.template isComponentOfType<K>(name);
    }
 
    std::type_index elemComponentType(const std::string& name) const
        requires comp::HasCustomComponents<T>
    {
        return mCustomCompVecMap.componentType(name);
    }
 
    template<typename K>
    std::vector<std::string> elemCustomComponentNamesOfType() const
        requires comp::HasCustomComponents<T>
    {
        return mCustomCompVecMap.template allComponentNamesOfType<K>();
    }
 
    template<typename K>
    void addElemCustomComponent(const std::string& name)
        requires comp::HasCustomComponents<T>
    {
        mCustomCompVecMap.template addNewComponent<K>(
            name, elementContainerSize());
    }
 
    void deleteElemCustomComponent(const std::string& name)
        requires comp::HasCustomComponents<T>
    {
        mCustomCompVecMap.deleteComponent(name);
    }
 
    template<typename K>
    CustomComponentVectorHandle<K> customComponentVectorHandle(
        const std::string& name) requires comp::HasCustomComponents<T>
    {
        std::vector<std::any>& cc =
            mCustomCompVecMap.template componentVector<K>(name);
        CustomComponentVectorHandle<K> v(cc);
        return v;
    }
 
    template<typename K>
    ConstCustomComponentVectorHandle<K> customComponentVectorHandle(
        const std::string& name) const requires comp::HasCustomComponents<T>
    {
        const std::vector<std::any>& cc =
            mCustomCompVecMap.template componentVector<K>(name);
        ConstCustomComponentVectorHandle<K> v(cc);
        return cc;
    }
 
    template<typename K>
    void serializePerElementCustomComponentsOfType(std::ostream& os) const
        requires comp::HasCustomComponents<T>
    {
        mCustomCompVecMap.template serializeCustomComponentsOfType<K>(os);
    }
 
    template<typename K>
    void deserializePerElementCustomComponentsOfType(std::istream& is)
        requires comp::HasCustomComponents<T>
    {
        mCustomCompVecMap.template deserializeCustomComponentsOfType<K>(is);
    }
 
    uint index(const T* e) const
    {
        assert(
            !mElemVec.empty() && e >= mElemVec.data() && e <= &mElemVec.back());
        return e - mElemVec.data();
    }
 
    void setParentMeshPointers(void* pm)
    {
        mParentMesh = static_cast<ParentMeshType*>(pm);
        for (auto& e : elements(false)) {
            e.setParentMesh(pm);
        }
    }
 
    template<typename Element>
    void updateReferences(
        const Element* oldBase,
        uint           firstElementToProcess = 0,
        uint           offset                = 0)
    {
        using Comps = T::Components;
 
        updateReferencesOnComponents(
            oldBase, Comps(), firstElementToProcess, offset);
    }
 
    template<typename Element>
    void updateReferences(const std::vector<uint>& newIndices)
    {
        using Comps = T::Components;
 
        updateReferencesOnComponents<Element>(newIndices, Comps());
    }
 
    void updateElementIndices(const std::vector<uint>& newIndices)
    {
        mParentMesh->template updateAllReferences<T>(newIndices);
    }
 
    template<typename OtherMesh>
    void enableOptionalComponentsOf(const OtherMesh& m)
    {
        if constexpr (OtherMesh::template hasContainerOf<T>()) {
            // get the container type of the other mesh for T - used to upcast
            // othMesh
            using OContainer = OtherMesh::template ContainerOf<T>::type;
 
            const OContainer& c = static_cast<const OContainer&>(m);
 
            enableSameOptionalComponents(typename T::Components(), c);
        }
    }
 
    template<typename OtherMesh>
    void importFrom(const OtherMesh& m)
    {
        if constexpr (OtherMesh::template hasContainerOf<T>()) {
            // get the container type of the other mesh for T - used to upcast
            // othMesh
            using Container = OtherMesh::template ContainerOf<T>::type;
 
            const Container& c = (const Container&) m;
 
            clearElements();
 
            // recreate a container having the same number of elements as the
            // other mesh. this call will also update the parentMesh pointers
            // and sets the vertical components vectors in vcVecTuple
            addElements(c.elementContainerSize());
            unsigned int eid = 0;
            for (const typename Container::ElementType& e : c.elements(false)) {
                // import the components of the e, when they are available.
                // note that will set also the deleted flag of e, therefore if e
                // is deleted, then also element(eid) will be deleted.
                element(eid).importFrom(e);
                ++eid;
            }
            // set the number of elements (different from the container size)
            mElemNumber = c.mElemNumber;
            if constexpr (
                comp::HasCustomComponents<T> &&
                comp::HasCustomComponents<typename Container::ElementType>) {
                mCustomCompVecMap = c.mCustomCompVecMap;
            }
        }
    }
 
private:
    template<typename ElPtr, typename... Comps>
    void updateReferencesOnComponents(
        const ElPtr* oldBase,
        TypeWrapper<Comps...>,
        uint firstElementToProcess = 0,
        uint offset                = 0)
    {
        (updateReferencesOnComponent<Comps>(
             oldBase, firstElementToProcess, offset),
         ...);
    }
 
    template<typename ElPtr, typename... Comps>
    void updateReferencesOnComponents(
        const std::vector<uint>& newIndices,
        TypeWrapper<Comps...>)
    {
        (updateReferencesOnComponent<Comps, ElPtr>(newIndices), ...);
    }
 
    /*
     * This function is called for each component of the element.
     *
     * Only if a component has references of the type ElPtr, then the
     * updateReferences on each element will be executed.
     *
     * firstElementToProcess and offset are used only when an append operation
     * has been executed. In this case, the firstElementToProcess is the index
     * of the first element that has been appended, and offset is the number of
     * ElPtr elements that have been appended (the offset that must be added
     * to the newBase w.r.t. the oldBase that was the other container from which
     * the elements have been copied).
     */
    template<typename Comp, typename ElPtr>
    void updateReferencesOnComponent(
        const ElPtr* oldBase,
        uint         firstElementToProcess = 0,
        uint         offset                = 0)
    {
        if constexpr (comp::HasReferencesOfType<Comp, ElPtr>) {
            // lambda to avoid code duplication
            auto loop = [&]() {
                for (uint i = firstElementToProcess; i < elementContainerSize();
                     i++) {
                    T& e = element(i);
                    if (!e.deleted()) {
                        e.Comp::updateReferences(oldBase, offset);
                    }
                }
            };
 
            if constexpr (comp::HasOptionalReferencesOfType<Comp, ElPtr>) {
                if (isOptionalComponentEnabled<Comp>()) {
                    loop();
                }
            }
            else {
                loop();
            }
        }
    }
 
    template<typename Comp, typename ElPtr>
    void updateReferencesOnComponent(const std::vector<uint>& newIndices)
    {
        if constexpr (comp::HasReferencesOfType<Comp, ElPtr>) {
            if constexpr (comp::HasOptionalReferencesOfType<Comp, ElPtr>) {
                if (isOptionalComponentEnabled<Comp>()) {
                    for (T& e : elements()) {
                        e.Comp::updateReferences(newIndices);
                    }
                }
            }
            else {
                for (T& e : elements()) {
                    e.Comp::updateReferences(newIndices);
                }
            }
        }
    }
 
    template<typename... Comps>
    void appendVerticalComponents(
        const ElementContainer<T>& other,
        TypeWrapper<Comps...>)
    {
        (appendVerticalComponent<Comps>(other), ...);
    }
 
    template<typename Comp>
    void appendVerticalComponent(const ElementContainer<T>& other)
    {
        uint on = other.elementContainerSize();
        uint n  = elementContainerSize() - on;
 
        if (mVerticalCompVecTuple.template isComponentEnabled<Comp>() &&
            other.mVerticalCompVecTuple.template isComponentEnabled<Comp>()) {
            auto&       vc = mVerticalCompVecTuple.template vector<Comp>();
            const auto& ovc =
                other.mVerticalCompVecTuple.template vector<Comp>();
 
            for (uint i = 0; i < on; ++i) {
                vc[n + i] = ovc[i];
            }
        }
    }
 
    void appendCustomComponents(const ElementContainer<T>& other)
    {
        if constexpr (comp::HasCustomComponents<T>) {
            uint on = other.elementContainerSize();
            uint n  = elementContainerSize() - on;
 
            std::vector<std::string> ccNames =
                mCustomCompVecMap.allComponentNames();
 
            for (const std::string& name : ccNames) {
                for (uint i = 0; i < on; ++i) {
                    mCustomCompVecMap.importSameCustomComponentFrom(
                        n + i, i, name, other.mCustomCompVecMap);
                }
            }
        }
    }
 
    template<typename Cont2, typename... Comps>
    void enableSameOptionalComponents(TypeWrapper<Comps...>, const Cont2& c2)
    {
        // for each Component in Comps, will call enableSameOptionalComponent
        (enableSameOptionalComponent<Comps>(c2), ...);
    }
 
    template<typename Comp, typename Cont2>
    void enableSameOptionalComponent(const Cont2& c2)
    {
        // if Comp is an optional component in This container
        if constexpr (comp::IsOptionalComponent<Comp>) {
            // if Comp is available in Cont2
            if constexpr (comp::HasComponentOfType<
                              typename Cont2::ElementType,
                              Comp::COMPONENT_ID>) {
                // if Comp is optional in Cont2
                if constexpr (comp::HasOptionalComponentOfType<
                                  typename Cont2::ElementType,
                                  Comp::COMPONENT_ID>) {
                    // if Comp is enabled in Cont2, we enable it in this
                    // container
                    if (c2.template isOptionalComponentEnabled<
                            Comp::COMPONENT_ID>()) {
                        enableOptionalComponent<Comp::COMPONENT_ID>();
                    }
                }
                // if Comp is not optional (but is available), we enable it in
                // this container
                else {
                    enableOptionalComponent<Comp::COMPONENT_ID>();
                }
            }
        }
    }
};
 
template<typename T>
concept ElementContainerConcept =
    std::derived_from< // same type or derived type
        std::remove_cvref_t<T>,
        ElementContainer<typename RemoveRef<T>::ElementType>>;
 
 
} // namespace vcl::mesh
 
#endif // VCL_MESH_CONTAINERS_BASE_ELEMENT_CONTAINER_H