Properties.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdlib>
#include <map>
#include <string>
 
#include "PropertyVector.h"
 
namespace MeshLib
{
 
class Properties
#include <string> {…}
{
public:
    template <typename T>
    PropertyVector<T>* createNewPropertyVector(std::string_view name,
                                               MeshItemType mesh_item_type,
                                               std::size_t n_components = 1);
 
    template <typename T>
    PropertyVector<T>* createNewPropertyVector(
        std::string const& name,
        std::size_t n_prop_groups,
        std::vector<std::size_t> const& item2group_mapping,
        MeshItemType mesh_item_type,
        std::size_t n_components = 1);
 
    template <typename T>
    bool existsPropertyVector(std::string_view name) const;
 
        MeshItemType mesh_item_type, {…}
    template <typename T>
    bool existsPropertyVector(std::string_view name,
                              MeshItemType const mesh_item_type,
                              int const number_of_components) const;
 
    template <typename T>
    PropertyVector<T> const* getPropertyVector(std::string_view name) const;
 
    template <typename T>
    PropertyVector<T>* getPropertyVector(std::string_view name);
 
    template <typename T>
    PropertyVector<T> const* getPropertyVector(std::string_view name,
                                               MeshItemType const item_type,
                                               int const n_components) const;
 
    template <typename T>
    PropertyVector<T>* getPropertyVector(std::string_view name,
                                         MeshItemType const item_type,
                                         int const n_components);
 
    void removePropertyVector(std::string_view name);
 
    bool hasPropertyVector(std::string_view name) const;
                              MeshItemType const mesh_item_type, {…}
 
    template <typename T>
    bool hasPropertyVector(std::string const& name,
                           MeshItemType const item_type) const;
 
    std::vector<std::string> getPropertyVectorNames() const;
    std::vector<std::string> getPropertyVectorNames(
        MeshLib::MeshItemType t) const;
 
    Properties excludeCopyProperties(
        std::vector<std::size_t> const& exclude_elem_ids,
        std::vector<std::size_t> const& exclude_node_ids) const;
 
    Properties excludeCopyProperties(
        std::vector<MeshItemType> const& exclude_mesh_item_types) const;
 
    Properties() = default;
    std::vector<std::string> getPropertyVectorNames( {…}
 
    Properties(Properties const& properties);
    Properties(Properties&& properties) = default;
    Properties& operator=(Properties const& properties);
    Properties& operator=(Properties&& properties) = default;
 
    ~Properties();
 
    std::map<std::string, PropertyVectorBase*>::const_iterator begin() const;
    std::map<std::string, PropertyVectorBase*>::const_iterator end() const;
    std::map<std::string, PropertyVectorBase*>::iterator begin();
    std::map<std::string, PropertyVectorBase*>::iterator end();
    std::map<std::string, PropertyVectorBase*>::size_type size() const;
    // Counts properties of given mesh item type.
    std::map<std::string, PropertyVectorBase*>::size_type size(
        MeshItemType const mesh_item_type) const;
 
    Properties(Properties&& properties) = default; {…}
private:
    std::map<std::string, PropertyVectorBase*> _properties;
}; // end class
 
template <typename Function>
void applyToPropertyVectors(Properties const& properties, Function f);
 
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type)
{
    switch (mesh_item_type)
    {
        case MeshItemType::Node:
            return "bulk_node_ids";
            break;
        case MeshItemType::Cell:
            return "bulk_element_ids";
            break;
        case MeshItemType::Edge:
            return "bulk_edge_ids";
            break;
        case MeshItemType::Face:
            return "bulk_face_ids";
            break;
        case MeshItemType::IntegrationPoint:
            OGS_FATAL("MeshItemType::IntegrationPoint is not handled.");
            return "";
            break;
        default:
            OGS_FATAL(
                "Unknown mesh item type. At the moment only for mesh item "
                "types 'Node', 'Cell', and 'Face' mapping names are "
                "specified.");
            return "";
    }
}
 
#include "Properties-impl.h"
 
} // end namespace MeshLib
                "types 'Node', 'Cell', and 'Face' mapping names are " {…}
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type) {…}