MeshLib::Properties Class Reference

Detailed Description

Property manager on mesh items. Class Properties manages scalar, vector or matrix properties. For instance in groundwater flow porosity is a scalar property and permeabilty can be stored as a tensor property. Properties are assigned to mesh items, i.e. Node or Element objects. The createNewPropertyVector() method first creates a PropertyVector of template type T (scalar, vector or matrix). This class stores the PropertyVector, accessible by a combination of the name and the type of the mesh item (Node or Element).

Definition at line 35 of file Properties.h.

#include <Properties.h>

Public Member Functions
template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string const &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 const &name) const
template<typename T >
bool	existsPropertyVector (std::string const &name, MeshItemType const mesh_item_type, int const number_of_components) const
template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string const &name) const
template<typename T >
PropertyVector< T > *	getPropertyVector (std::string const &name)
template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string const &name, MeshItemType const item_type, int const n_components) const
template<typename T >
PropertyVector< T > *	getPropertyVector (std::string const &name, MeshItemType const item_type, int const n_components)
void	removePropertyVector (std::string const &name)
bool	hasPropertyVector (std::string const &name) 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
std::map< std::string, PropertyVectorBase * >::size_type	size (MeshItemType const mesh_item_type) const
template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string const &name, MeshItemType mesh_item_type, std::size_t n_components)
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)
template<typename T >
bool	existsPropertyVector (std::string const &name) const
template<typename T >
bool	existsPropertyVector (std::string const &name, MeshItemType const mesh_item_type, int const number_of_components) const
template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string const &name) const
template<typename T >
PropertyVector< T > *	getPropertyVector (std::string const &name)
template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string const &name, MeshItemType const item_type, int const n_components) const
template<typename T >
PropertyVector< T > *	getPropertyVector (std::string const &name, MeshItemType const item_type, int const n_components)

Private Attributes
std::map< std::string, PropertyVectorBase * >	_properties

Constructor & Destructor Documentation

Properties() [1/3]

MeshLib::Properties::Properties ( )

default

Properties() [2/3]

MeshLib::Properties::Properties

(

Properties const &

properties

)

Definition at line 104 of file Properties.cpp.

    : _properties(properties._properties)
{
    std::vector<std::size_t> exclude_positions;
    for (auto& name_vector_pair : _properties)
    {
        PropertyVectorBase* t(
            name_vector_pair.second->clone(exclude_positions));
        name_vector_pair.second = t;
    }
}

References _properties.

Properties() [3/3]

MeshLib::Properties::Properties ( Properties &&  properties )

default

~Properties()

MeshLib::Properties::~Properties

(

)

Definition at line 135 of file Properties.cpp.

{
    for (auto name_vector_pair : _properties)
    {
        delete name_vector_pair.second;
    }
}

References _properties.

Member Function Documentation

begin() [1/2]

std::map< std::string, PropertyVectorBase * >::iterator MeshLib::Properties::begin

(

)

Definition at line 155 of file Properties.cpp.

{
    return _properties.begin();
}

References _properties.

begin() [2/2]

std::map< std::string, PropertyVectorBase * >::const_iterator MeshLib::Properties::begin

(

)

const

Definition at line 143 of file Properties.cpp.

{
    return _properties.cbegin();
}

References _properties.

Referenced by size().

createNewPropertyVector() [1/4]

template<typename T >

PropertyVector<T>* MeshLib::Properties::createNewPropertyVector	(	std::string const &	name,
		MeshItemType	mesh_item_type,
		std::size_t	n_components
	)

Definition at line 14 of file Properties-impl.h.

{
    std::map<std::string, PropertyVectorBase*>::const_iterator it(
        _properties.find(name)
    );
    if (it != _properties.end()) {
        ERR("A property of the name '{:s}' is already assigned to the mesh.",
            name);
        return nullptr;
    }
    auto entry_info(
        _properties.insert(
            std::make_pair(
                name, new PropertyVector<T>(name, mesh_item_type, n_components)
            )
        )
    );
    return static_cast<PropertyVector<T>*>((entry_info.first)->second);
}

References ERR(), and MaterialPropertyLib::name.

createNewPropertyVector() [2/4]

template<typename T >

PropertyVector<T>* MeshLib::Properties::createNewPropertyVector	(	std::string const &	name,
		MeshItemType	mesh_item_type,
		std::size_t	n_components = 1
	)

Method creates a PropertyVector if a PropertyVector with the same name and the same type T was not already created before. In case there exists already such a PropertyVector a nullptr is returned. There are two versions of this method. This method is used when every mesh item at hand has its own property value, i.e. \(n\) mesh item and \(n\) different property values. The user has to ensure the correct usage of the vector later on.

Template Parameters

T	type of the property value

Parameters

name	the name of the property
mesh_item_type	for instance node or element assigned properties
n_components	number of components for each tuple

Returns

A pointer to a PropertyVector on success and a nullptr otherwise.

Referenced by CreateStructuredGridDialog::accept(), MeshLib::addPropertyToMesh(), ApplicationUtils::addVtkGhostTypeProperty(), castPropertyVectorToPropertyVector(), MeshLib::RasterToMesh::convert(), MeshLib::VtkMeshConverter::convertTypedArray(), MeshLib::MeshRevision::copyProperties(), ApplicationUtils::copyPropertyVector(), MeshLib::MeshLayerMapper::createStaticLayers(), LayeredMeshGenerator::getMesh(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), main(), mapArray(), FileIO::Gocad::GocadAsciiReader::parseProperties(), FileIO::Gocad::GocadAsciiReader::readData(), FileIO::GMSInterface::readGMS3DMMesh(), FileIO::GMSH::readGMSHMesh(), FileIO::SwmmInterface::readSwmmInputToLineMesh(), FileIO::TetGenInterface::readTetGenMesh(), MeshLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), and writeDataToMesh().

createNewPropertyVector() [3/4]

template<typename T >

PropertyVector<T>* MeshLib::Properties::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
	)

Definition at line 38 of file Properties-impl.h.

{
    // check if there is already a PropertyVector with the same name
    std::map<std::string, PropertyVectorBase*>::const_iterator it(
        _properties.find(name)
    );
    if (it != _properties.end()) {
        ERR("A property of the name '{:s}' already assigned to the mesh.",
            name);
        return nullptr;
    }
 
    // check entries of item2group_mapping for consistence
    for (std::size_t k(0); k<item2group_mapping.size(); k++) {
        std::size_t const group_id (item2group_mapping[k]);
        if (group_id >= n_prop_groups) {
            ERR("The mapping to property {:d} for item {:d} is not in the "
                "correct range [0,{:d}).",
                group_id, k, n_prop_groups);
            return nullptr;
        }
    }
 
    auto entry_info(
        _properties.insert(
            std::pair<std::string, PropertyVectorBase*>(
                name,
                new PropertyVector<T>(n_prop_groups,
                    item2group_mapping, name, mesh_item_type, n_components)
            )
        )
    );
    return static_cast<PropertyVector<T>*>((entry_info.first)->second);
}

References ERR(), and MaterialPropertyLib::name.

createNewPropertyVector() [4/4]

template<typename T >

PropertyVector<T>* MeshLib::Properties::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
	)

Method creates a PropertyVector if a PropertyVector with the same name and the same type T was not already created before. In case there exists already such a PropertyVector a nullptr is returned. This method is used if only a small number of distinct property values in a property exist (e.g. mapping property groups to elements). In this case a mapping between mesh items and properties (stored on the heap), see the parameter item2group_mapping, is required.

Template Parameters

T	type of the property value

Parameters

name	the name of the property
n_prop_groups	number of distinct property groups
item2group_mapping	the mapping between mesh item and the property group
mesh_item_type	for instance node or element assigned properties
n_components	number of components for each tuple

Returns

A pointer to a PropertyVector on success and a nullptr otherwise.

end() [1/2]

std::map< std::string, PropertyVectorBase * >::iterator MeshLib::Properties::end

(

)

Definition at line 160 of file Properties.cpp.

{
    return _properties.end();
}

References _properties.

end() [2/2]

std::map< std::string, PropertyVectorBase * >::const_iterator MeshLib::Properties::end

(

)

const

Definition at line 149 of file Properties.cpp.

{
    return _properties.cend();
}

References _properties.

Referenced by size().

excludeCopyProperties() [1/2]

Properties MeshLib::Properties::excludeCopyProperties

(

std::vector< MeshItemType > const &

exclude_mesh_item_types

)

const

copy all PropertyVector objects stored in the (internal) map but PropertyVector objects with the given MeshItemType are excluded.

Definition at line 82 of file Properties.cpp.

{
    Properties new_properties;
    for (auto name_vector_pair : _properties)
    {
        if (std::find(exclude_mesh_item_types.begin(),
                      exclude_mesh_item_types.end(),
                      name_vector_pair.second->getMeshItemType()) !=
            exclude_mesh_item_types.end())
        {
            continue;
        }
 
        std::vector<std::size_t> const exclude_positions{};
        new_properties._properties.insert(
            std::make_pair(name_vector_pair.first,
                           name_vector_pair.second->clone(exclude_positions)));
    }
    return new_properties;
}

References _properties.

excludeCopyProperties() [2/2]

Properties MeshLib::Properties::excludeCopyProperties	(	std::vector< std::size_t > const &	exclude_elem_ids,
		std::vector< std::size_t > const &	exclude_node_ids
	)		const

copy all PropertyVector objects stored in the (internal) map but only those nodes/elements of a PropertyVector whose ids are not in the vectors exclude_*_ids.

Definition at line 58 of file Properties.cpp.

{
    Properties exclude_copy;
    for (auto name_vector_pair : _properties)
    {
        if (name_vector_pair.second->getMeshItemType() == MeshItemType::Cell)
        {
            exclude_copy._properties.insert(std::make_pair(
                name_vector_pair.first,
                name_vector_pair.second->clone(exclude_elem_ids)));
        }
        else if (name_vector_pair.second->getMeshItemType() ==
                 MeshItemType::Node)
        {
            exclude_copy._properties.insert(std::make_pair(
                name_vector_pair.first,
                name_vector_pair.second->clone(exclude_node_ids)));
        }
    }
    return exclude_copy;
}

References _properties, MeshLib::Cell, and MeshLib::Node.

Referenced by MeshLib::convertToLinearMesh(), MeshLib::createQuadraticOrderMesh(), MeshLib::removeElements(), and MeshLib::removeNodes().

existsPropertyVector() [1/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector

(

std::string const &

name

)

const

Definition at line 79 of file Properties-impl.h.

{
    auto it(_properties.find(name));
    // Check that a PropertyVector with the appropriate name exists.
    if (it == _properties.end())
    {
        return false;
    }
    // Check that the PropertyVector has the correct data type.
    return dynamic_cast<PropertyVector<T> const*>(it->second) != nullptr;
}

References MaterialPropertyLib::name.

existsPropertyVector() [2/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector

(

std::string const &

name

)

const

Checks if a property vector with given name and the given type exists.

Parameters

name	name of the requested property vector

Referenced by MeshLib::ElementStatus::ElementStatus(), ProcessLib::SolutionDependentDirichletBoundaryCondition::SolutionDependentDirichletBoundaryCondition(), MeshElementRemovalDialog::accept(), MeshLib::addLayerToMesh(), ProcessLib::addProcessDataToMesh(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), MeshLib::MeshRevision::copyProperties(), ProcessLib::getIntegrationPointMetaData(), MeshLib::getOrCreateMeshProperty(), getSurfaceIntegratedValuesForNodes(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess(), MeshLib::Mesh2MeshPropertyInterpolation::interpolateElementPropertiesToNodeProperties(), MeshLib::materialIDs(), MeshElementRemovalDialog::on_scalarArrayComboBox_currentIndexChanged(), MeshLib::scaleMeshPropertyVector(), MeshLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), MeshLib::IO::Legacy::MeshIO::write(), and FileIO::TetGenInterface::write2dElements().

existsPropertyVector() [3/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector	(	std::string const &	name,
		MeshItemType const	mesh_item_type,
		int const	number_of_components
	)		const

Definition at line 92 of file Properties-impl.h.

{
    auto const it = _properties.find(name);
    if (it == _properties.end())
    {
        return false;
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        return false;
    }
    if (property->getMeshItemType() != mesh_item_type)
    {
        return false;
    }
    if (property->getNumberOfGlobalComponents() != number_of_components)
    {
        return false;
    }
    return true;
}

References MaterialPropertyLib::name.

existsPropertyVector() [4/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector	(	std::string const &	name,
		MeshItemType const	mesh_item_type,
		int const	number_of_components
	)		const

Checks if a property vector with given type T, name, mesh_item_type, and number_of_components exists.

getPropertyVector() [1/8]

template<typename T >

PropertyVector<T>* MeshLib::Properties::getPropertyVector

(

std::string const &

name

)

Definition at line 139 of file Properties-impl.h.

{
    auto it(_properties.find(name));
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with the specified name '{:s}' is not available.",
            name);
    }
    if (!dynamic_cast<PropertyVector<T>*>(it->second))
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has a different type than the requested "
            "PropertyVector.",
            name);
    }
    return dynamic_cast<PropertyVector<T>*>(it->second);
}

References MaterialPropertyLib::name, and OGS_FATAL.

getPropertyVector() [2/8]

template<typename T >

PropertyVector<T>* MeshLib::Properties::getPropertyVector

(

std::string const &

name

)

Returns a property vector with given name or aborts calling OGS_FATAL if no such property vector exists.

getPropertyVector() [3/8]

template<typename T >

PropertyVector<T> const* MeshLib::Properties::getPropertyVector

(

std::string const &

name

)

const

Definition at line 119 of file Properties-impl.h.

{
    auto it(_properties.find(name));
    if (it == _properties.end())
    {
        OGS_FATAL("The PropertyVector '{:s}' is not available in the mesh.",
                  name);
    }
    if (!dynamic_cast<PropertyVector<T> const*>(it->second))
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has a different type than the requested "
            "PropertyVector.",
            name);
    }
    return dynamic_cast<PropertyVector<T> const*>(it->second);
}

References MaterialPropertyLib::name, and OGS_FATAL.

getPropertyVector() [4/8]

template<typename T >

PropertyVector<T> const* MeshLib::Properties::getPropertyVector

(

std::string const &

name

)

const

Returns a property vector with given name or aborts calling OGS_FATAL if no such property vector exists.

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), MeshLib::ElementStatus::ElementStatus(), ProcessLib::LIE::PostProcessTool::PostProcessTool(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), MeshLib::addLayerToMesh(), ProcessLib::addProcessDataToMesh(), castPropertyVectorToPropertyVector(), MeshLib::ElementValueModification::condense(), MeshLib::MeshRevision::copyProperties(), ParameterLib::createGroupBasedParameter(), ParameterLib::createMeshElementParameter(), ParameterLib::createMeshNodeParameter(), ParameterLib::createRandomFieldMeshElementParameter(), extractMatGroup(), ProcessLib::PythonBoundaryCondition::getEssentialBCValues(), getSurfaceIntegratedValuesForNodes(), anonymous_namespace{IdentifySubdomainMesh.cpp}::identifySubdomainMeshElements(), MeshLib::Mesh2MeshPropertyInterpolation::interpolateElementPropertiesToNodeProperties(), mapArray(), markFaults(), MeshElementRemovalDialog::on_scalarArrayComboBox_currentIndexChanged(), FileIO::Gocad::GocadAsciiReader::parseElements(), FileIO::Gocad::GocadAsciiReader::parseLineSegments(), ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), MeshLib::ElementValueModification::replace(), MeshGeoToolsLib::resetMeshElementProperty(), MeshLib::scaleMeshPropertyVector(), MeshLib::ElementSearch::searchByPropertyValueRange(), MeshLib::ElementValueModification::setByElementType(), setMaterialIDs(), MeshLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), MeshLib::IO::Legacy::MeshIO::write(), FileIO::TetGenInterface::write2dElements(), and FileIO::TetGenInterface::write3dElements().

getPropertyVector() [5/8]

template<typename T >

PropertyVector<T>* MeshLib::Properties::getPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type,
		int const	n_components
	)

Definition at line 197 of file Properties-impl.h.

{
    auto const it = _properties.find(name);
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with name '{:s}' does not exist in the mesh.",
            name);
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        OGS_FATAL(
            "Could not cast the data type of the PropertyVector '{:s}' to "
            "requested data type.",
            name);
    }
    if (property->getMeshItemType() != item_type)
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has type '{:s}'. A '{:s}' field is "
            "requested.",
            name, toString(property->getMeshItemType()), toString(item_type));
    }
    if (property->getNumberOfGlobalComponents() != n_components)
    {
        OGS_FATAL(
            "PropertyVector '{:s}' has {:d} components, {:d} components are "
            "needed.",
            name, property->getNumberOfGlobalComponents(), n_components);
    }
    return property;
}

References MaterialPropertyLib::name, OGS_FATAL, and MaterialLib::Solids::MFront::toString().

getPropertyVector() [6/8]

template<typename T >

PropertyVector<T>* MeshLib::Properties::getPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type,
		int const	n_components
	)

Non-const version of getPropertyVector returns a property vector with given name, item_type and number_of_components or calls OGS_FATAL if no such property vector exists.

getPropertyVector() [7/8]

template<typename T >

PropertyVector<T> const* MeshLib::Properties::getPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type,
		int const	n_components
	)		const

Definition at line 159 of file Properties-impl.h.

{
    auto const it = _properties.find(name);
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with name '{:s}' does not exist in the mesh.",
            name);
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        OGS_FATAL(
            "Could not cast the data type of the PropertyVector '{:s}' to "
            "requested data type.",
            name);
    }
    if (property->getMeshItemType() != item_type)
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has type '{:s}'. A '{:s}' field is "
            "requested.",
            name, toString(property->getMeshItemType()), toString(item_type));
    }
    if (property->getNumberOfGlobalComponents() != n_components)
    {
        OGS_FATAL(
            "PropertyVector '{:s}' has {:d} components, {:d} components are "
            "needed.",
            name, property->getNumberOfGlobalComponents(), n_components);
    }
    return property;
}

References MaterialPropertyLib::name, OGS_FATAL, and MaterialLib::Solids::MFront::toString().

getPropertyVector() [8/8]

template<typename T >

PropertyVector<T> const* MeshLib::Properties::getPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type,
		int const	n_components
	)		const

Returns a property vector with given name, item_type and number_of_components or aborts calling OGS_FATAL if no such property vector exists.

getPropertyVectorNames() [1/2]

std::vector< std::string > MeshLib::Properties::getPropertyVectorNames

(

)

const

Definition at line 35 of file Properties.cpp.

{
    std::vector<std::string> names;
    std::transform(_properties.begin(), _properties.end(),
                   std::back_inserter(names),
                   [](auto const& pair) { return pair.first; });
    return names;
}

References _properties.

Referenced by MeshLib::MeshRevision::copyProperties().

getPropertyVectorNames() [2/2]

std::vector< std::string > MeshLib::Properties::getPropertyVectorNames

(

MeshLib::MeshItemType

t

)

const

Definition at line 44 of file Properties.cpp.

{
    std::vector<std::string> names;
    for (auto p : _properties)
    {
        if (p.second->getMeshItemType() == t)
        {
            names.push_back(p.first);
        }
    }
    return names;
}

References _properties.

hasPropertyVector()

bool MeshLib::Properties::hasPropertyVector

(

std::string const &

name

)

const

Check if a PropertyVector accessible by the name is already stored within the Properties object.

Parameters

name	the name of the property (for instance porosity)

Definition at line 30 of file Properties.cpp.

{
    return _properties.find(name) != _properties.end();
}

References _properties, and MaterialPropertyLib::name.

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool().

operator=() [1/2]

Properties& MeshLib::Properties::operator= ( Properties &&  properties )

default

operator=() [2/2]

Properties & MeshLib::Properties::operator=

(

Properties const &

properties

)

Definition at line 116 of file Properties.cpp.

{
    if (&properties == this)
    {
        return *this;
    }
 
    _properties = properties._properties;
    std::vector<std::size_t> exclude_positions;
    for (auto& name_vector_pair : _properties)
    {
        PropertyVectorBase* t(
            name_vector_pair.second->clone(exclude_positions));
        name_vector_pair.second = t;
    }
 
    return *this;
}

References _properties.

removePropertyVector()

void MeshLib::Properties::removePropertyVector

(

std::string const &

name

)

Definition at line 17 of file Properties.cpp.

{
    std::map<std::string, PropertyVectorBase*>::const_iterator it(
        _properties.find(name));
    if (it == _properties.end())
    {
        WARN("A property of the name '{:s}' does not exist.", name);
        return;
    }
    delete it->second;
    _properties.erase(it);
}

References _properties, MaterialPropertyLib::name, and WARN().

size() [1/2]

std::map< std::string, PropertyVectorBase * >::size_type MeshLib::Properties::size

(

)

const

Definition at line 165 of file Properties.cpp.

{
    return _properties.size();
}

References _properties.

Referenced by ApplicationUtils::writeProperties().

size() [2/2]

std::map< std::string, PropertyVectorBase * >::size_type MeshLib::Properties::size

(

MeshItemType const

mesh_item_type

)

const

Definition at line 170 of file Properties.cpp.

{
    return count_if(begin(), end(),
                    [&](auto const p)
                    { return p.second->getMeshItemType() == mesh_item_type; });
}

References begin(), and end().

Member Data Documentation

_properties

std::map<std::string, PropertyVectorBase*> MeshLib::Properties::_properties

private

A mapping from property's name to the stored object of any type. See addProperty() and getProperty() documentation.

Definition at line 165 of file Properties.h.

Referenced by Properties(), ~Properties(), begin(), end(), excludeCopyProperties(), getPropertyVectorNames(), hasPropertyVector(), operator=(), removePropertyVector(), and size().

---

The documentation for this class was generated from the following files:

• MeshLib/Properties.h
• MeshLib/Properties-impl.h
• MeshLib/Properties.cpp