custom_components_vector_map.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_DETAIL_CUSTOM_COMPONENTS_VECTOR_MAP_H
#define VCL_MESH_CONTAINERS_DETAIL_CUSTOM_COMPONENTS_VECTOR_MAP_H
 
#include <vclib/mesh/exceptions.h>
 
#include <vclib/base.h>
 
#include <any>
#include <string>
#include <typeindex>
#include <unordered_map>
#include <vector>
 
namespace vcl::mesh::detail {
 
template<bool HasCustomComponent>
class CustomComponentsVectorMap
{
};
 
template<>
class CustomComponentsVectorMap<true>
{
    // the actual map containing, for each name of a custom component, the
    // vector of values (a value for each element(vertex/face...) of the mesh)
    std::unordered_map<std::string, std::vector<std::any>> mMap;
    // map that stores if some custom components need to be initialized.
    // this happens when we resize the container of an element: we need to
    // resize also the vectors of the custom components, but we cannot
    // initialize them with the right type (because we don't know it in resize
    // phase). The initialization will be made when the type is known (get of
    // the custom component vector).
    mutable std::unordered_map<std::string, bool> mNeedToInitialize;
    // types used for each custom component
    std::unordered_map<std::string, std::type_index> mCompType;
 
public:
    void clear()
    {
        mMap.clear();
        mNeedToInitialize.clear();
        mCompType.clear();
    }
 
    void reserve(uint size)
    {
        for (auto& p : mMap) {
            p.second.reserve(size);
        }
    }
 
    void resize(uint size)
    {
        for (auto& p : mMap) {
            // At this call, we don't know statically the types of each custom
            // component, therefore we cannot initialize them (std::any of each
            // vector will be in an invalid state). Therefore, we mark all the
            // resized custom components as 'needToInitialize'. Initiaization
            // will be made just on the uninitialized values of the vectors at
            // the first access of each custom component.
            if (p.second.size() < size)
                mNeedToInitialize.at(p.first) = true;
            p.second.resize(size);
        }
    }
 
    void compact(const std::vector<uint>& newIndices)
    {
        for (auto& p : mMap) {
            compactVector(p.second, newIndices);
        }
    }
 
    void swapCustomComponents(uint i, uint j)
    {
        for (auto& p : mMap) {
            std::swap(p.second[i], p.second[j]);
        }
    }
 
    template<typename CompType>
    void addNewComponent(const std::string& name, uint size)
    {
        std::vector<std::any>& v = mMap[name];
        v.resize(size, CompType());
        mNeedToInitialize[name] = false;
        mCompType.emplace(name, typeid(CompType));
    }
 
    void deleteComponent(const std::string& name)
    {
        mMap.erase(name);
        mNeedToInitialize.erase(name);
        mCompType.erase(name);
    }
 
    void assertComponentExists(const std::string& compName) const
    {
        (void) (compName);
        assert(mMap.find(compName) != mMap.end());
    }
 
    bool componentExists(const std::string& compName) const
    {
        return (mMap.find(compName) != mMap.end());
    }
 
    std::vector<std::string> allComponentNames() const
    {
        std::vector<std::string> names;
        names.reserve(mMap.size());
        for (const auto& p : mMap)
            names.push_back(p.first);
        return names;
    }
 
    template<typename CompType>
    bool isComponentOfType(const std::string& compName) const
    {
        std::type_index t(typeid(CompType));
 
        return t == mCompType.at(compName);
    }
 
    std::type_index componentType(const std::string& compName) const
    {
        return mCompType.at(compName);
    }
 
    template<typename CompType>
    std::vector<std::string> allComponentNamesOfType() const
    {
        std::vector<std::string> names;
        std::type_index          t(typeid(CompType));
        for (const auto& p : mCompType) {
            if (p.second == t)
                names.push_back(p.first);
        }
        return names;
    }
 
    template<typename CompType>
    const std::vector<std::any>& componentVector(
        const std::string& compName) const
    {
        checkComponentType<CompType>(compName);
        std::vector<std::any>& v =
            const_cast<std::vector<std::any>&>(mMap.at(compName));
        // if the component needs to be initialized (e.g. we made a resize)
        if (mNeedToInitialize.at(compName)) {
            for (std::any& a : v) {
                if (!a.has_value())
                    a = CompType();
            }
            mNeedToInitialize.at(compName) = false;
        }
        return v;
    }
 
    template<typename CompType>
    std::vector<std::any>& componentVector(const std::string& compName)
    {
        checkComponentType<CompType>(compName);
        std::vector<std::any>& v = mMap.at(compName);
        // if the component needs to be initialized (e.g. we made a resize)
        if (mNeedToInitialize.at(compName)) {
            for (std::any& a : v) {
                if (!a.has_value())
                    a = CompType();
            }
            mNeedToInitialize.at(compName) = false;
        }
        return v;
    }
 
    void importSameCustomComponentFrom(
        uint                                   thisPos,
        uint                                   otherPos,
        const std::string&                     compName,
        const CustomComponentsVectorMap<true>& other)
    {
        if (other.componentExists(compName) && componentExists(compName)) {
            if (other.componentType(compName) == componentType(compName)) {
                mMap.at(compName)[thisPos] = other.mMap.at(compName)[otherPos];
            }
        }
    }
 
    template<typename CompType>
    void serializeCustomComponentsOfType(std::ostream& os) const
    {
        std::vector<std::string> compNames =
            allComponentNamesOfType<CompType>();
        vcl::serialize(os, compNames);
        for (const auto& name : compNames) {
            bool b = mNeedToInitialize.at(name);
            vcl::serialize(os, b);
            const std::vector<std::any>& v = componentVector<CompType>(name);
            vcl::serialize<CompType>(os, v);
        }
    }
 
    template<typename CompType>
    void deserializeCustomComponentsOfType(std::istream& is)
    {
        std::vector<std::string> compNames;
        vcl::deserialize(is, compNames);
        for (const auto& name : compNames) {
            bool b;
            vcl::deserialize(is, b);
            std::vector<std::any> v;
            vcl::deserialize<CompType>(is, v);
            mMap[name]              = v;
            mNeedToInitialize[name] = b;
            mCompType.emplace(name, typeid(CompType));
        }
    }
 
private:
    template<typename CompType>
    void checkComponentType(const std::string& compName) const
    {
        std::type_index t(typeid(CompType));
        if (t != mCompType.at(compName)) {
            throw BadCustomComponentTypeException(
                "Expected type " + std::string(mCompType.at(compName).name()) +
                " for " + compName + ", but was " + std::string(t.name()) +
                ".");
        }
    }
};
 
} // namespace vcl::mesh::detail
 
#endif // VCL_MESH_CONTAINERS_DETAIL_CUSTOM_COMPONENTS_VECTOR_MAP_H