vcl::MeshConcept Concept Reference

The Mesh Concept is evaluated to true when the type is a Mesh. More...

#include <vclib/concepts/mesh/mesh_concept.h>

Concept definition

template<typename T>
concept vcl::MeshConcept = 
    
    mesh::HasVertexContainer<T> && requires (
                                       T&&                                obj,
                                       typename RemoveRef<T>::VertexType  v,
                                       typename RemoveRef<T>::VertexType& vR,
                                       typename RemoveRef<T>::VertexType* vP,
                                       std::vector<uint>                  vec) {
        
        typename RemoveRef<T>::Containers;
        typename RemoveRef<T>::Components;
 
        
        
        requires std::same_as<
            decltype(v),
            typename RemoveRef<T>::template ElementType<ElemId::VERTEX>>;
 
        
        requires RemoveRef<T>::template hasContainerOf<decltype(v)>();
 
        
        requires RemoveRef<T>::template hasContainerOf<ElemId::VERTEX>();
 
        
        requires RemoveRef<T>::template hasPerElementComponent<
            ElemId::VERTEX,
            CompId::COORDINATE>();
 
        
        RemoveRef<T>();
        RemoveRef<T>(obj);
 
        
        { obj.isCompact() } -> std::same_as<bool>;
        { obj.index(v) } -> std::same_as<uint>;
 
        
        {
            obj.template element<ElemId::VERTEX>(uint())
        } -> std::convertible_to<decltype(v)>;
 
        { obj.template number<ElemId::VERTEX>() } -> std::same_as<uint>;
        { obj.template containerSize<ElemId::VERTEX>() } -> std::same_as<uint>;
        { obj.template deletedNumber<ElemId::VERTEX>() } -> std::same_as<uint>;
        {
            obj.template compactIndices<ElemId::VERTEX>()
        } -> std::same_as<decltype(vec)>;
 
        { obj.template begin<ElemId::VERTEX>() } -> InputIterator<decltype(v)>;
        {
            obj.template begin<ElemId::VERTEX>(bool())
        } -> InputIterator<decltype(v)>;
        { obj.template end<ElemId::VERTEX>() } -> InputIterator<decltype(v)>;
        { obj.template elements<ElemId::VERTEX>() } -> InputRange<decltype(v)>;
        {
            obj.template elements<ElemId::VERTEX>(bool())
        } -> InputRange<decltype(v)>;
 
        
        requires IsConst<T> || requires {
            
            { obj.clear() } -> std::same_as<void>;
            { obj.compact() } -> std::same_as<void>;
            { obj.enableAllOptionalComponents() } -> std::same_as<void>;
            { obj.disableAllOptionalComponents() } -> std::same_as<void>;
            { obj.enableSameOptionalComponentsOf(obj) } -> std::same_as<void>;
            { obj.append(obj) } -> std::same_as<void>;
            { obj.importFrom(obj) } -> std::same_as<void>;
            { obj.swap(obj) } -> std::same_as<void>;
            { obj.deleteElement(v) } -> std::same_as<void>;
            { obj.deleteElement(vP) } -> std::same_as<void>;
 
            
            { obj = obj } -> std::same_as<T&>;
 
            
            {
                obj.template element<ElemId::VERTEX>(uint())
            } -> std::same_as<decltype(vR)>;
            { obj.template add<ElemId::VERTEX>() } -> std::same_as<uint>;
            { obj.template add<ElemId::VERTEX>(uint()) } -> std::same_as<uint>;
            {
                obj.template clearElements<ElemId::VERTEX>()
            } -> std::same_as<void>;
            {
                obj.template resize<ElemId::VERTEX>(uint())
            } -> std::same_as<void>;
            {
                obj.template reserve<ElemId::VERTEX>(uint())
            } -> std::same_as<void>;
            {
                obj.template deleteElement<ElemId::VERTEX>(uint())
            } -> std::same_as<void>;
            {
                obj.template updateIndices<ElemId::VERTEX>(vec)
            } -> std::same_as<void>;
 
            {
                obj.template begin<ElemId::VERTEX>()
            } -> OutputIterator<decltype(v)>;
            {
                obj.template begin<ElemId::VERTEX>(bool())
            } -> OutputIterator<decltype(v)>;
            {
                obj.template end<ElemId::VERTEX>()
            } -> OutputIterator<decltype(v)>;
            {
                obj.template elements<ElemId::VERTEX>()
            } -> OutputRange<decltype(v)>;
            {
                obj.template elements<ElemId::VERTEX>(bool())
            } -> OutputRange<decltype(v)>;
        };
    }

Detailed Description

The Mesh Concept is evaluated to true when the type is a Mesh.

A type T is a Mesh when it contains a VertexContainer, which is the only container that is mandatory in a vcl::Mesh, and provides:

• A type definition called Containers, which is a TypeWrapper that contains all the containers that the Mesh has.
• A type definition called Components, which is a TypeWrapper that contains all the components that the Mesh has.
• A method called clear() that clears the mesh.
• A method called isCompact() that returns a boolean indicating if the mesh is compact.
• A method called compact() that compacts the mesh.
• A method called enableSameOptionalComponentsOf() that enables the same optional components of another mesh.
• A method called importFrom() that imports the mesh from another mesh.
• A method called swap() that swaps the mesh with another mesh.