SimplexCollection.hpp

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <wmtk/Mesh.hpp>
#include "Simplex.hpp"
#include "internal/SimplexEqualFunctor.hpp"
#include "internal/SimplexLessFunctor.hpp"
 
namespace wmtk::simplex {
class SimplexCollection
{
public:
    SimplexCollection(const Mesh& mesh, std::vector<Simplex>&& simplices = {})
        : m_mesh{mesh}
        , m_simplices(std::move(simplices))
        , m_simplex_is_less(mesh)
        , m_simplex_is_equal(mesh)
    {
        m_simplices.reserve(100);
    }
 
    const std::vector<Simplex>& simplex_vector() const { return m_simplices; }
    std::vector<Simplex> simplex_vector(const PrimitiveType& ptype) const;
 
    const Mesh& mesh() const;
 
    std::vector<Tuple> simplex_vector_tuples(PrimitiveType ptype) const;
 
    void add(const Simplex& simplex);
 
    void add(const SimplexCollection& simplex_collection);
 
    void add(const PrimitiveType ptype, const std::vector<Tuple>& tuple_vec);
 
    void add(const PrimitiveType ptype, const Tuple& tuple);
    void sort_and_clean();
    void sort();
 
    bool contains(const Simplex& simplex) const;
 
    static SimplexCollection get_union(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
    static SimplexCollection get_intersection(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
    static bool are_simplex_collections_equal(
        const SimplexCollection& collection_a,
        const SimplexCollection& collection_b);
 
 
    auto begin() { return m_simplices.begin(); }
    auto end() { return m_simplices.end(); }
    auto begin() const { return m_simplices.begin(); }
    auto end() const { return m_simplices.end(); }
    auto cbegin() const { return m_simplices.cbegin(); }
    auto cend() const { return m_simplices.cend(); }
 
    bool operator==(const SimplexCollection& other) const;
 
    inline size_t size() const { return m_simplices.size(); }
 
    void reserve(const size_t new_cap);
 
 
protected:
    const Mesh& m_mesh;
    std::vector<Simplex> m_simplices;
 
protected:
    internal::SimplexLessFunctor m_simplex_is_less;
    internal::SimplexEqualFunctor m_simplex_is_equal;
};
} // namespace wmtk::simplex