MeshLib/Properties.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <cstdlib>
#include <map>
#include <string>
 
#include "BaseLib/Error.h"
#include "PropertyVector.h"
 
namespace MeshLib
{

class Properties
{
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_view name,
                                               MeshItemType mesh_item_type,
                                               std::size_t n_property_values,
                                               std::size_t n_components);

    template <typename T>
    bool existsPropertyVector(std::string_view name) const;

    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;

    template <typename T>
    bool hasPropertyVector(std::string_view 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;
 
    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;
 
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 mapping names only "
                "for mesh item types 'Node', 'Cell', 'Edge', and 'Face' are "
                "specified.",
                static_cast<int>(mesh_item_type));
            return "";
    }
}
 
constexpr std::string_view globalIDString(
    MeshLib::MeshItemType const mesh_item_type)
{
    switch (mesh_item_type)
    {
        case MeshLib::MeshItemType::Node:
        {
            return "global_node_ids";
        }
        case MeshLib::MeshItemType::Cell:
        {
            return "global_element_ids";
        }
        case MeshItemType::Edge:
            OGS_FATAL("MeshItemType::Edge is not handled in globalIDString.");
        case MeshItemType::Face:
            OGS_FATAL("MeshItemType::Face is not handled in globalIDString.");
        case MeshItemType::IntegrationPoint:
            OGS_FATAL(
                "MeshItemType::IntegrationPoint is not handled in "
                "globalIDString.");
        default:
            return "";
    }
}
 
}  // end namespace MeshLib
 
#include "Properties-impl.h"