vcl::comp::HasVertexReferences Concept Reference

HasVertexReferences concept is satisfied only if a Element class provides the types and member functions specified in this concept. These types and member functions allow to access to a vcl::comp::VertexReferences component of a given element. More...

#include <vclib/concepts/mesh/components/vertex_references.h>

Concept definition

template<typename T>
concept vcl::comp::HasVertexReferences =  requires (
    T&&                                             obj,
    typename RemoveRef<T>::VertexType               v,
    typename RemoveRef<T>::VertexIterator           it,
    typename RemoveRef<T>::ConstVertexIterator      cIt,
    typename RemoveRef<T>::ConstVertexIndexIterator cIIt,
    typename RemoveRef<T>::VertexType*              vP,
    const typename RemoveRef<T>::VertexType*        cVP,
    std::vector<typename RemoveRef<T>::VertexType*> vecV,
    std::vector<uint>                               vecU) {
    RemoveRef<T>::VERTEX_NUMBER;
 
    typename RemoveRef<T>::VertexType;
    typename RemoveRef<T>::VertexIterator;
    typename RemoveRef<T>::ConstVertexIterator;
    typename RemoveRef<T>::ConstVertexIndexIterator;
 
    { obj.vertexNumber() } -> std::same_as<uint>;
 
    { obj.vertex(uint()) } -> std::convertible_to<decltype(cVP)>;
    { obj.vertexIndex(uint()) } -> std::same_as<uint>;
    { obj.vertexMod(int()) } -> std::convertible_to<decltype(cVP)>;
    { obj.vertexIndexMod(int()) } -> std::same_as<uint>;
 
    { obj.containsVertex(&v) } -> std::same_as<bool>;
    { obj.containsVertex(uint()) } -> std::same_as<bool>;
    { obj.indexOfVertex(&v) } -> std::same_as<uint>;
    { obj.indexOfVertex(uint()) } -> std::same_as<uint>;
    { obj.indexOfEdge(&v, &v) } -> std::same_as<uint>;
    { obj.indexOfEdge(uint(), uint()) } -> std::same_as<uint>;
 
    { obj.vertexBegin() } -> InputIterator<decltype(cVP)>;
    { obj.vertexEnd() } -> InputIterator<decltype(cVP)>;
 
    { obj.vertexIndexBegin() } -> InputIterator<uint>;
    { obj.vertexIndexEnd() } -> InputIterator<uint>;
 
    { obj.vertices() } -> InputRange<decltype(cVP)>;
    { obj.vertexIndices() } -> InputRange<uint>;
 
    
    requires IsConst<T> || requires {
        { obj.vertex(uint()) } -> std::same_as<decltype(vP)>;
        { obj.vertexMod(int()) } -> std::same_as<decltype(vP)>;
 
        { obj.setVertex(uint(), &v) } -> std::same_as<void>;
        { obj.setVertex(uint(), uint()) } -> std::same_as<void>;
        { obj.setVertex(it, &v) } -> std::same_as<void>;
        { obj.setVertex(it, uint()) } -> std::same_as<void>;
        { obj.setVertex(cIt, &v) } -> std::same_as<void>;
        { obj.setVertex(cIt, uint()) } -> std::same_as<void>;
        { obj.setVertex(cIIt, &v) } -> std::same_as<void>;
        { obj.setVertex(cIIt, uint()) } -> std::same_as<void>;
        { obj.setVertexMod(int(), &v) } -> std::same_as<void>;
        { obj.setVertexMod(int(), uint()) } -> std::same_as<void>;
        { obj.setVertices(vecV) } -> std::same_as<void>;
        { obj.setVertices(vecU) } -> std::same_as<void>;
 
        
        
        
        
        
        
        { obj.vertexBegin() } -> InputIterator<decltype(vP)>;
        { obj.vertexEnd() } -> InputIterator<decltype(vP)>;
 
        { obj.vertices() } -> InputRange<decltype(vP)>;
    };
}

Detailed Description

HasVertexReferences concept is satisfied only if a Element class provides the types and member functions specified in this concept. These types and member functions allow to access to a vcl::comp::VertexReferences component of a given element.