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