pointer_container_component.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_COMPONENTS_BASE_POINTER_CONTAINER_COMPONENT_H
#define VCL_MESH_COMPONENTS_BASE_POINTER_CONTAINER_COMPONENT_H
 
#include "container_component.h"
 
#include <vclib/mesh/iterators/components/index_from_pointer_iterator.h>
 
#include <vclib/base.h>
 
namespace vcl::comp {
 
 
template<
    typename DerivedComponent, // CRTP pattern, derived class
    uint COMP_ID,              // component id
    typename Elem,             // element type for which the pointers are stored
    int N,                     // container size
    typename ParentElemType,   // parent element type
    bool VERT,                 // true if component vertical
    bool OPT,                  // true if component vertical and optional
    bool TTVN>                 // true if container size tied to vertex number
class PointerContainerComponent :
        public ContainerComponent<
            DerivedComponent,
            COMP_ID,
            Elem*,
            N,
            void,
            ParentElemType,
            VERT,
            OPT,
            TTVN,
            Elem>
{
    using Base = ContainerComponent<
        DerivedComponent,
        COMP_ID,
        Elem*,
        N,
        void,
        ParentElemType,
        VERT,
        OPT,
        TTVN,
        Elem>;
 
public:
    template<typename T>
    auto pointers() const requires std::is_same_v<T, Elem>
    {
        return View(
            ConstIterator(Base::container().begin()),
            ConstIterator(Base::container().end()));
    }
 
protected:
    using Base::container;
 
    using Iterator      = Base::ConstIterator;
    using ConstIterator = ConstPointerIterator<typename Base::ConstIterator>;
    using ConstIndexIterator = IndexFromPointerIterator<ConstIterator>;
 
    /*
     * This member function is called when we need to update the pointers in
     * this container after a reallocation (the pointer of the first element of
     * the container of Elem is changed).
     *
     * This is necessary when, for example, the original container of Elements
     * has been reallocated. When this happens, the all the Elements have been
     * moved in another portion of memory, and all the pointers to that Elements
     * must be updated. Since in this container are stored pointers to Elements,
     * we need to update them.
     *
     * To update them, we need to know the oldBase (the pointer to the first
     * Element of the reallocated Container before the reallocation). We can
     * then compute, for each pointer, the difference w.r.t. the old address of
     * the first element of the Container, and update the the pointer
     * accordingly using the new base of the Container, which is computed
     * trough the parent mesh.
     *
     * When we perform an append operation, we need to update the pointers
     * taking into account also the offset: when we append a new element in a
     * container, only its pointers must be updated. To update from the old
     * pointers to the new ones, we need to know how many elements were in the
     * container BEFORE the append operation, and this becomes the offset to
     * be applied to the pointers of the newly appended elements.
     */
    void updateReferences(const Elem* oldBase, std::size_t offset = 0)
    {
        const Elem* newBase = baseOfElemContainer();
 
        auto& baseContainer = Base::container();
 
        for (uint j = 0; j < baseContainer.size();
             ++j) { // for each pointer in this container
            if (baseContainer.at(j) != nullptr) {
                size_t diff =
                    baseContainer.at(j) - oldBase; // offset w.r.t. the old base
 
                // update the pointer using newBase
                baseContainer.at(j) = (Elem*) newBase + diff + offset;
            }
        }
    }
 
    /*
     * This member function is called when we need to update the pointers in
     * this containers, usually after a compaction of the container (but not
     * always).
     *
     * In this case, the address of the first element in the container is not
     * changed, but may change the position of each element inside the
     * container. The function takes the base pointer of the first element of
     * the container, and a vector that stores, for each old element position,
     * the new position in the container (UINT_NULL if the element has been
     * removed and must be left unreferenced).
     */
    void updateReferences(const std::vector<uint>& newIndices)
    {
        const Elem* base = baseOfElemContainer();
 
        auto& baseContainer = Base::container();
 
        for (uint j = 0; j < baseContainer.size(); ++j) {
            if (baseContainer.at(j) != nullptr) {
                size_t diff = baseContainer.at(j) - base;
                if (newIndices[diff] == UINT_NULL) { // element has been removed
                    baseContainer.at(j) = nullptr;
                }
                else { // the new pointer will be base + newIndices[diff]
                    baseContainer.at(j) = (Elem*) base + newIndices[diff];
                }
            }
        }
    }
 
private:
    const Elem* baseOfElemContainer() const
    {
        return &(Base::parentElement()
                     ->parentMesh()
                     ->template element<Elem::ELEMENT_ID>(0));
    }
};
 
 
} // namespace vcl::comp
 
#endif // VCL_MESH_COMPONENTS_BASE_POINTER_CONTAINER_COMPONENT_H