Detailed Description

template<typename T>
class MeshLib::PropertyVector< T * >

Class template PropertyVector is a std::vector with template parameter T, where T is a pointer type. The behaviour has changed for the constructor, destructor and the operator[]. The user has to provide the size and an item to group mapping for construction. The destructor takes care to delete the entries of the vector. The operator[] uses an item-to-group property map to access the correct property.

Template Parameters

T	pointer type, the type the type points to is typical a scalar, a vector or a matrix type

Definition at line 139 of file PropertyVector.h.

#include <PropertyVector.h>

Inheritance diagram for MeshLib::PropertyVector< T * >:

[legend]

Collaboration diagram for MeshLib::PropertyVector< T * >:

[legend]

Public Member Functions
	~PropertyVector () override
	Destructor ensures the deletion of the heap-constructed objects. More...

T *const &	operator[] (std::size_t id) const

T *&	operator[] (std::size_t id)

void	initPropertyValue (std::size_t group_id, T const &value)

void	initPropertyValue (std::size_t group_id, std::vector< T > const &values)

std::size_t	getNumberOfTuples () const

std::size_t	size () const

PropertyVectorBase *	clone (std::vector< std::size_t > const &exclude_positions) const override

T const &	getComponent (std::size_t tuple_index, int component) const
	Returns the value for the given component stored in the given tuple. More...

std::ostream &	print (std::ostream &os) const

Public Member Functions inherited from MeshLib::PropertyVectorBase
virtual	~PropertyVectorBase ()=default

MeshItemType	getMeshItemType () const

std::string const &	getPropertyName () const

int	getNumberOfGlobalComponents () const

Protected Member Functions
	PropertyVector (std::size_t n_prop_groups, std::vector< std::size_t > item2group_mapping, std::string const &property_name, MeshItemType mesh_item_type, std::size_t n_components)
	The constructor taking meta information for the data. More...

Protected Member Functions inherited from MeshLib::PropertyVectorBase
	PropertyVectorBase (std::string property_name, MeshItemType mesh_item_type, std::size_t n_components)

Private Member Functions
T *	at (std::size_t)

Private Attributes
std::vector< T * >	_values

Friends
class	Properties

Additional Inherited Members
Protected Attributes inherited from MeshLib::PropertyVectorBase
int const	_n_components

MeshItemType const	_mesh_item_type

std::string const	_property_name

Constructor & Destructor Documentation

◆ ~PropertyVector()

template<typename T >

MeshLib::PropertyVector< T * >::~PropertyVector ( )

inlineoverride

Destructor ensures the deletion of the heap-constructed objects.

Definition at line 146 of file PropertyVector.h.

     {
         for (auto v : _values)
         {
             delete[] v;
         }
     }

◆ PropertyVector()

template<typename T >

MeshLib::PropertyVector< T * >::PropertyVector	(	std::size_t	n_prop_groups,
		std::vector< std::size_t >	item2group_mapping,
		std::string const &	property_name,
		MeshItemType	mesh_item_type,
		std::size_t	n_components
	)

inlineprotected

The constructor taking meta information for the data.

Parameters

n_prop_groups	number of different property values
item2group_mapping	Class Mesh has a mapping from the mesh items (Node or Element) to an index (position in the data structure). The vector item2group_mapping must have the same number of entries as the above mapping and the values have to be in the range \([0, \text{n\_prop\_groups})\).
property_name	a string describing the property
mesh_item_type	the values of the property are either assigned to nodes or cells (see enumeration MeshItemType)
n_components	the number of elements of a tuple

Definition at line 270 of file PropertyVector.h.

         : std::vector<std::size_t>(std::move(item2group_mapping)),
           PropertyVectorBase(property_name, mesh_item_type, n_components),
           _values(n_prop_groups * n_components)
     {
     }

Member Function Documentation

◆ at()

template<typename T >

T* MeshLib::PropertyVector< T * >::at ( std::size_t )

private

◆ clone()

template<typename T >

PropertyVectorBase* MeshLib::PropertyVector< T * >::clone ( std::vector< std::size_t > const & exclude_positions ) const

inlineoverridevirtual

Implements MeshLib::PropertyVectorBase.

Definition at line 208 of file PropertyVector.h.

     {
         // create new PropertyVector with modified mapping
         PropertyVector<T*>* t(new PropertyVector<T*>(
             _values.size() / _n_components,
             BaseLib::excludeObjectCopy(*this, exclude_positions),
             _property_name, _mesh_item_type, _n_components));
         // copy pointers to property values
         for (std::size_t j(0); j < _values.size(); j++)
         {
             std::vector<T> values(_values[j], _values[j] + _n_components);
             t->initPropertyValue(j, values);
         }
         return t;
     }

References BaseLib::excludeObjectCopy(), and initPropertyValue().

◆ getComponent()

template<typename T >

T const& MeshLib::PropertyVector< T * >::getComponent	(	std::size_t	tuple_index,
		int	component
	)		const

inline

Returns the value for the given component stored in the given tuple.

Definition at line 226 of file PropertyVector.h.

     {
         assert(component < _n_components);
         assert(tuple_index < getNumberOfTuples());
         const double* p = this->operator[](tuple_index);
         if (p == nullptr)
         {
             OGS_FATAL(
                 "No data found in the property vector {:s} "
                 "for the tuple index {:d} and component {:d}",
                 getPropertyName(), tuple_index, component);
         }
         return p[component];
     }

References OGS_FATAL, and MathLib::p.

◆ getNumberOfTuples()

template<typename T >

std::size_t MeshLib::PropertyVector< T * >::getNumberOfTuples ( ) const

inline

Definition at line 196 of file PropertyVector.h.

     {
         return std::vector<std::size_t>::size();
     }

◆ initPropertyValue() [1/2]

template<typename T >

void MeshLib::PropertyVector< T * >::initPropertyValue	(	std::size_t	group_id,
		std::vector< T > const &	values
	)

inline

Definition at line 179 of file PropertyVector.h.

     {
         if (_n_components != static_cast<int>(values.size()))
         {
             OGS_FATAL(
                 "The size of provided values in initPropertyValue() is "
                 "not same as the number of components in PropertyVector<T*>");
         }
  
         auto* p = new T[values.size()];
         for (unsigned i = 0; i < values.size(); i++)
         {
             p[i] = values[i];
         }
         _values[group_id] = p;
     }

References OGS_FATAL, and MathLib::p.

◆ initPropertyValue() [2/2]

template<typename T >

void MeshLib::PropertyVector< T * >::initPropertyValue	(	std::size_t	group_id,
		T const &	value
	)

inline

Definition at line 166 of file PropertyVector.h.

     {
         if (_n_components != 1)
         {
             OGS_FATAL(
                 "Single-component version of initPropertyValue() is called "
                 "for a multi-components PropertyVector<T*>");
         }
         auto* p = new T[1];
         p[0] = value;
         _values[group_id] = p;
     }

References OGS_FATAL, and MathLib::p.

Referenced by clone().

◆ operator[]() [1/2]

template<typename T >

T*& MeshLib::PropertyVector< T * >::operator[] ( std::size_t id )

inline

Definition at line 161 of file PropertyVector.h.

     {
         return _values[std::vector<std::size_t>::operator[](id)];
     }

◆ operator[]() [2/2]

template<typename T >

T* const& MeshLib::PropertyVector< T * >::operator[] ( std::size_t id ) const

inline

The operator[] uses the item to group property map to access to the correct property value/object.

Definition at line 156 of file PropertyVector.h.

     {
         return _values[std::vector<std::size_t>::operator[](id)];
     }

◆ print()

template<typename T >

std::ostream& MeshLib::PropertyVector< T * >::print ( std::ostream & os ) const

inline

Definition at line 242 of file PropertyVector.h.

     {
         os << "\nPropertyVector<T*> at address: " << this << ":\n";
         os << "\tmapping (" << size() << "):\n";
         std::copy(this->cbegin(), this->cend(),
                   std::ostream_iterator<std::size_t>(os, " "));
         os << "\n\tvalues (" << _values.size() << "):\n";
         for (std::size_t k(0); k < _values.size(); k++)
         {
             os << "val: " << *(_values[k]) << ", address: " << _values[k]
                << "\n";
         }
         return os;
     }

References MathLib::LinAlg::copy().

◆ size()

template<typename T >

std::size_t MeshLib::PropertyVector< T * >::size ( ) const

inline

Method returns the number of tuples times the number of tuple components.

Definition at line 203 of file PropertyVector.h.

     {
         return _n_components * std::vector<std::size_t>::size();
     }

Friends And Related Function Documentation

◆ Properties

template<typename T >

friend class Properties

friend

Definition at line 142 of file PropertyVector.h.

Member Data Documentation

◆ _values

template<typename T >

std::vector<T*> MeshLib::PropertyVector< T * >::_values

private

Definition at line 283 of file PropertyVector.h.

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

MeshLib/PropertyVector.h

Detailed Description

template<typename T> class MeshLib::PropertyVector< T * >

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Constructor & Destructor Documentation

◆ ~PropertyVector()

◆ PropertyVector()

Member Function Documentation

◆ at()

◆ clone()

◆ getComponent()

◆ getNumberOfTuples()

◆ initPropertyValue() [1/2]

◆ initPropertyValue() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ print()

◆ size()

Friends And Related Function Documentation

◆ Properties

Member Data Documentation

◆ _values

template<typename T>
class MeshLib::PropertyVector< T * >