vcl::mesh::HasEdgeContainer Concept Reference

The HasEdgeContainer concept is satisfied only if a container class provides the types and member functions specified in this concept. These types and member functions allow to access to a vcl::mesh::EdgeContainer container of a given mesh. More...

#include <vclib/concepts/mesh/containers/edge_container.h>

Concept definition

template<typename T>
concept vcl::mesh::HasEdgeContainer =  requires (
    T&&                                          obj,
    typename RemoveRef<T>::EdgeType              e,
    typename RemoveRef<T>::EdgeType*             eP,
    typename RemoveRef<T>::EdgeType&             eR,
    typename RemoveRef<T>::EdgeType::VertexType* vP,
    std::vector<uint>                            vec) {
    typename RemoveRef<T>::EdgeType;
    typename RemoveRef<T>::EdgeIterator;
    typename RemoveRef<T>::ConstEdgeIterator;
 
    { obj.edge(uint()) } -> std::convertible_to<decltype(e)>;
    { obj.edgeNumber() } -> std::same_as<uint>;
    { obj.edgeContainerSize() } -> std::same_as<uint>;
    { obj.deletedEdgeNumber() } -> std::same_as<uint>;
 
    { obj.edgeIndexIfCompact(uint()) } -> std::same_as<uint>;
    { obj.edgeCompactIndices() } -> std::same_as<decltype(vec)>;
 
    { obj.edgeBegin() } -> InputIterator<decltype(e)>;
    { obj.edgeEnd() } -> InputIterator<decltype(e)>;
    { obj.edges() } -> InputRange<decltype(e)>;
    { obj.edges(bool()) } -> InputRange<decltype(e)>;
 
    
    requires IsConst<T> || requires {
        { obj.edge(uint()) } -> std::same_as<decltype(eR)>;
 
        { obj.addEdge() } -> std::same_as<uint>;
        { obj.addEdge(uint(), uint()) } -> std::same_as<uint>;
        { obj.addEdge(vP, vP) } -> std::same_as<uint>;
        { obj.addEdges(uint()) } -> std::same_as<uint>;
        { obj.clearEdges() } -> std::same_as<void>;
        { obj.resizeEdges(uint()) } -> std::same_as<void>;
        { obj.reserveEdges(uint()) } -> std::same_as<void>;
        { obj.compactEdges() } -> std::same_as<void>;
        { obj.deleteEdge(uint()) } -> std::same_as<void>;
        { obj.deleteEdge(eP) } -> std::same_as<void>;
        { obj.updateEdgeIndices(vec) } -> std::same_as<void>;
 
        { obj.edgeBegin() } -> OutputIterator<decltype(e)>;
        { obj.edgeEnd() } -> OutputIterator<decltype(e)>;
 
        { obj.edges() } -> OutputRange<decltype(e)>;
        { obj.edges(bool()) } -> OutputRange<decltype(e)>;
 
        { obj.enableAllPerEdgeOptionalComponents() } -> std::same_as<void>;
        { obj.disableAllPerEdgeOptionalComponents() } -> std::same_as<void>;
    };
}

Detailed Description

The HasEdgeContainer concept is satisfied only if a container class provides the types and member functions specified in this concept. These types and member functions allow to access to a vcl::mesh::EdgeContainer container of a given mesh.