index_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_INDEX_CONTAINER_COMPONENT_H
#define VCL_MESH_COMPONENTS_BASE_INDEX_CONTAINER_COMPONENT_H
 
#include "container_component.h"
 
#include <vclib/mesh/iterators/components/pointer_from_index_iterator.h>
 
#include <vclib/space/core.h>
 
namespace vcl::comp {
 
 
template<
    typename DerivedComponent, // CRTP pattern, derived class
    uint COMP_ID,              // component id
    typename Elem,             // element type for which the indices 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 IndexContainerComponent :
        public ContainerComponent<
            DerivedComponent,
            COMP_ID,
            uint,
            N,
            void,
            ParentElemType,
            VERT,
            OPT,
            TTVN,
            Elem>
{
    using Base = ContainerComponent<
        DerivedComponent,
        COMP_ID,
        uint,
        N,
        void,
        ParentElemType,
        VERT,
        OPT,
        TTVN,
        Elem>;
 
public:
    IndexContainerComponent()
    {
        if constexpr (!Base::IS_VERTICAL) {
            init();
        }
    }
 
    void init()
    {
        if constexpr (N >= 0) {
            container().fill(UINT_NULL);
        }
    }
 
    template<typename T>
    const auto& indices() const requires std::is_same_v<T, Elem>
    {
        return container();
    }
 
protected:
    using Base::container;
 
    using ConstIndexIterator = typename Base::ConstIterator;
    using Iterator =
        PointerFromIndexIterator<ConstIndexIterator, Elem, ParentElemType>;
    using ConstIterator =
        ConstPointerFromIndexIterator<ConstIndexIterator, Elem, ParentElemType>;
 
    /*
     * This member function is called when we need to update the indices in
     * this container after a reallocation (the pointer of the first element of
     * the container of Elem is changed).
     *
     * With respect to the updateReferences function of the
     * PointerContainerComponent, we need to do something only when offset is
     * different from 0, because in this case the indices of the elements have
     * changed (append case).
     *
     * When we append elements, this function is called only on the elements
     * that have been appended, and the offset is the number of referenced
     * elements that were in the container before the append operation.
     */
    void updateReferences(const Elem*, std::size_t offset = 0)
    {
        if (offset != 0) {
            auto& baseContainer = Base::container();
 
            for (uint j = 0; j < baseContainer.size(); ++j) {
                if (baseContainer.at(j) != UINT_NULL) {
                    baseContainer.at(j) += offset;
                }
            }
        }
    }
 
    /*
     * This member function is called when we need to update the pointers or
     * indices in this containers, usually after a compaction of the container
     * (but not always).
     *
     * In this case, indices must be updated, because the indices of the
     * elements have changed.
     */
    void updateReferences(const std::vector<uint>& newIndices)
    {
        auto& baseContainer = Base::container();
 
        for (uint j = 0; j < baseContainer.size(); ++j) {
            if (baseContainer.at(j) != UINT_NULL) {
                baseContainer.at(j) = newIndices.at(baseContainer.at(j));
            }
        }
    }
};
 
 
} // namespace vcl::comp
 
#endif // VCL_MESH_COMPONENTS_BASE_INDEX_CONTAINER_COMPONENT_H