edge_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_EDGE_CONTAINER_H
#define VCL_MESH_CONTAINERS_EDGE_CONTAINER_H
 
#include "element_container.h"
 
#include <vclib/mesh/containers/custom_component_vector_handle.h>
#include <vclib/mesh/elements/edge.h>
#include <vclib/mesh/elements/edge_components.h>
 
namespace vcl::mesh {
 
template<EdgeConcept T>
class EdgeContainer : public ElementContainer<T>
{
    template<EdgeConcept U>
    friend class EdgeContainer;
 
    using EdgeContainerType = EdgeContainer<T>;
    using Base              = ElementContainer<T>;
 
public:
    using Edge              = T;
    using EdgeType          = T;
    using EdgeIterator      = Base::ElementIterator;
    using ConstEdgeIterator = Base::ConstElementIterator;
 
    EdgeContainer() = default;
 
    const EdgeType& edge(uint i) const { return Base::element(i); }
 
    EdgeType& edge(uint i) { return Base::element(i); }
 
    uint edgeNumber() const { return Base::elementNumber(); }
 
    uint edgeContainerSize() const { return Base::elementContainerSize(); }
 
    uint deletedEdgeNumber() const { return Base::deletedElementNumber(); }
 
    uint addEdge() { return Base::addElement(); }
 
    uint addEdge(uint v0, uint v1)
    {
        uint eid = addEdge();
        edge(eid).setVertex(0U, v0);
        edge(eid).setVertex(1U, v1);
        return eid;
    }
 
    uint addEdge(typename T::VertexType* v0, typename T::VertexType* v1)
    {
        uint eid = addEdge();
        edge(eid).setVertex(0U, v0);
        edge(eid).setVertex(1U, v1);
        return eid;
    }
 
    uint addEdges(uint n) { return Base::addElements(n); }
 
    void clearEdges() { Base::clearElements(); }
 
    void resizeEdges(uint n) { Base::resizeElements(n); }
 
    void reserveEdges(uint n) { Base::reserveElements(n); }
 
    void compactEdges() { Base::compactElements(); }
 
    void deleteEdge(uint i) { Base::deleteElement(i); }
 
    void deleteEdge(const EdgeType* e) { Base::deleteElement(e); }
 
    uint edgeIndexIfCompact(uint i) const
    {
        return Base::elementIndexIfCompact(i);
    }
 
    std::vector<uint> edgeCompactIndices() const
    {
        return Base::elementCompactIndices();
    }
 
    void updateEdgeIndices(const std::vector<uint>& newIndices)
    {
        Base::updateElementIndices(newIndices);
    }
 
    EdgeIterator edgeBegin(bool jumpDeleted = true)
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    EdgeIterator edgeEnd() { return Base::elementEnd(); }
 
    ConstEdgeIterator edgeBegin(bool jumpDeleted = true) const
    {
        return Base::elementBegin(jumpDeleted);
    }
 
    ConstEdgeIterator edgeEnd() const { return Base::elementEnd(); }
 
    auto edges(bool jumpDeleted = true) { return Base::elements(jumpDeleted); }
 
    auto edges(bool jumpDeleted = true) const
    {
        return Base::elements(jumpDeleted);
    }
 
    void enableAllPerEdgeOptionalComponents()
    {
        Base::enableAllOptionalComponents();
    }
 
    void disableAllPerEdgeOptionalComponents()
    {
        Base::disableAllOptionalComponents();
    }
 
    // AdjacentEdges
 
    bool isPerEdgeAdjacentEdgesEnabled() const
        requires edge::HasOptionalAdjacentEdges<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentEdges>();
    }
 
    void enablePerEdgeAdjacentEdges() requires edge::HasOptionalAdjacentEdges<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    void disablePerEdgeAdjacentEdges()
        requires edge::HasOptionalAdjacentEdges<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentEdges>();
    }
 
    // AdjacentFaces
 
    bool isPerEdgeAdjacentFacesEnabled() const
        requires edge::HasOptionalAdjacentFaces<T>
    {
        return Base::template isOptionalComponentEnabled<
            typename T::AdjacentFaces>();
    }
 
    void enablePerEdgeAdjacentFaces() requires edge::HasOptionalAdjacentFaces<T>
    {
        Base::template enableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    void disablePerEdgeAdjacentFaces()
        requires edge::HasOptionalAdjacentFaces<T>
    {
        Base::template disableOptionalComponent<typename T::AdjacentFaces>();
    }
 
    // Color
 
    bool isPerEdgeColorEnabled() const requires edge::HasOptionalColor<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Color>();
    }
 
    void enablePerEdgeColor() requires edge::HasOptionalColor<T>
    {
        Base::template enableOptionalComponent<typename T::Color>();
    }
 
    void disablePerEdgeColor() requires edge::HasOptionalColor<T>
    {
        Base::template disableOptionalComponent<typename T::Color>();
    }
 
    // Mark
 
    bool isPerEdgeMarkEnabled() const requires edge::HasOptionalMark<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Mark>();
    }
 
    void enablePerEdgeMark() requires edge::HasOptionalMark<T>
    {
        Base::template enableOptionalComponent<typename T::Mark>();
    }
 
    void disablePerEdgeMark() requires edge::HasOptionalMark<T>
    {
        Base::template disableOptionalComponent<typename T::Mark>();
    }
 
    // Quality
 
    bool isPerEdgeQualityEnabled() const requires edge::HasOptionalQuality<T>
    {
        return Base::template isOptionalComponentEnabled<typename T::Quality>();
    }
 
    void enablePerEdgeQuality() requires edge::HasOptionalQuality<T>
    {
        Base::template enableOptionalComponent<typename T::Quality>();
    }
 
    void disablePerEdgeQuality() requires edge::HasOptionalQuality<T>
    {
        Base::template disableOptionalComponent<typename T::Quality>();
    }
 
    // Custom Components
 
    bool hasPerEdgeCustomComponent(const std::string& name) const
        requires edge::HasCustomComponents<T>
    {
        return Base::hasElemCustomComponent(name);
    }
 
    std::vector<std::string> perEdgeCustomComponentNames() const
        requires edge::HasCustomComponents<T>
    {
        return Base::elemCustomComponentNames();
    }
 
    template<typename K>
    bool isPerEdgeCustomComponentOfType(const std::string& name) const
        requires edge::HasCustomComponents<T>
    {
        return Base::template isElemCustomComponentOfType<K>(name);
    }
 
    std::type_index perEdgeCustomComponentType(const std::string& name) const
        requires edge::HasCustomComponents<T>
    {
        return Base::elemComponentType(name);
    }
 
    template<typename K>
    std::vector<std::string> perEdgeCustomComponentNamesOfType() const
        requires edge::HasCustomComponents<T>
    {
        return Base::template elemCustomComponentNamesOfType<K>();
    }
 
    template<typename K>
    void addPerEdgeCustomComponent(const std::string& name)
        requires edge::HasCustomComponents<T>
    {
        Base::template addElemCustomComponent<K>(name);
    }
 
    void deletePerEdgeCustomComponent(const std::string& name)
        requires edge::HasCustomComponents<T>
    {
        Base::deleteElemCustomComponent(name);
    }
 
    template<typename K>
    CustomComponentVectorHandle<K> perEdgeCustomComponentVectorHandle(
        const std::string& name) requires edge::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
 
    template<typename K>
    ConstCustomComponentVectorHandle<K> perEdgeCustomComponentVectorHandle(
        const std::string& name) const requires edge::HasCustomComponents<T>
    {
        return Base::template customComponentVectorHandle<K>(name);
    }
};
 
} // namespace vcl::mesh
 
#endif // VCL_MESH_CONTAINERS_EDGE_CONTAINER_H