PropertyVector.h

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <iterator>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
 
#include "BaseLib/Algorithm.h"
#include "Location.h"
 
namespace MeshLib
{
class PropertyVectorBase
{
public:
    virtual PropertyVectorBase* clone(
        std::vector<std::size_t> const& exclude_positions) const = 0;
    virtual ~PropertyVectorBase() = default;
 
    MeshItemType getMeshItemType() const { return _mesh_item_type; }
    std::string const& getPropertyName() const { return _property_name; }
    int getNumberOfGlobalComponents() const { return _n_components; }
 
protected:
    PropertyVectorBase(std::string property_name,
                       MeshItemType mesh_item_type,
                       std::size_t n_components)
        : _n_components(n_components),
          _mesh_item_type(mesh_item_type),
          _property_name(std::move(property_name))
    {
    }
 
    int const _n_components;
    MeshItemType const _mesh_item_type;
    std::string const _property_name;
};
 
template <typename PROP_VAL_TYPE>
class PropertyVector : public std::vector<PROP_VAL_TYPE>,
                       public PropertyVectorBase
{
    friend class Properties;
 
public:
    std::size_t getNumberOfTuples() const
    {
        return std::vector<PROP_VAL_TYPE>::size() / _n_components;
    }
 
    PROP_VAL_TYPE& getComponent(std::size_t tuple_index, int component)
    {
        assert(component < _n_components);
        assert(tuple_index < getNumberOfTuples());
        return this->operator[](tuple_index* getNumberOfGlobalComponents() +
                                component);
    }
 
    PROP_VAL_TYPE const& getComponent(std::size_t tuple_index,
                                      int component) const
    {
        assert(component < _n_components);
        assert(tuple_index < getNumberOfTuples());
        return this->operator[](tuple_index* getNumberOfGlobalComponents() +
                                component);
    }
 
    PropertyVectorBase* clone(
        std::vector<std::size_t> const& exclude_positions) const override
    {
        auto* t(new PropertyVector<PROP_VAL_TYPE>(
            _property_name, _mesh_item_type, _n_components));
        BaseLib::excludeObjectCopy(*this, exclude_positions, *t);
        return t;
    }
 
    std::size_t size() const { return std::vector<PROP_VAL_TYPE>::size(); }
 
protected:
    explicit PropertyVector(std::string const& property_name,
                            MeshItemType mesh_item_type,
                            std::size_t n_components)
        : std::vector<PROP_VAL_TYPE>(),
          PropertyVectorBase(property_name, mesh_item_type, n_components)
    {
    }
 
    PropertyVector(std::size_t n_property_values,
                   std::string const& property_name,
                   MeshItemType mesh_item_type,
                   std::size_t n_components)
        : std::vector<PROP_VAL_TYPE>(n_property_values * n_components),
          PropertyVectorBase(property_name, mesh_item_type, n_components)
    {
    }
};
 
template <typename T>
class PropertyVector<T*> : public std::vector<std::size_t>,
                           public PropertyVectorBase
{
    friend class Properties;
 
public:
    ~PropertyVector() override
    {
        for (auto v : _values)
        {
            delete[] v;
        }
    }
 
    T* const& operator[](std::size_t id) const
    {
        return _values[std::vector<std::size_t>::operator[](id)];
    }
 
    T*& operator[](std::size_t id)
    {
        return _values[std::vector<std::size_t>::operator[](id)];
    }
 
    void initPropertyValue(std::size_t group_id, T const& value)
    {
        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;
    }
 
    void initPropertyValue(std::size_t group_id, std::vector<T> const& values)
    {
        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;
    }
 
    std::size_t getNumberOfTuples() const
    {
        return std::vector<std::size_t>::size();
    }
 
    std::size_t size() const
    {
        return _n_components * std::vector<std::size_t>::size();
    }
 
    PropertyVectorBase* clone(
        std::vector<std::size_t> const& exclude_positions) const override
    {
        // 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;
    }
 
    T const& getComponent(std::size_t tuple_index, int component) const
    {
        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];
    }
 
#ifndef NDEBUG
    std::ostream& print(std::ostream& os) const
    {
        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;
    }
#endif
 
protected:
    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)
        : std::vector<std::size_t>(std::move(item2group_mapping)),
          PropertyVectorBase(property_name, mesh_item_type, n_components),
          _values(n_prop_groups * n_components)
    {
    }
 
private:
    std::vector<T*> _values;
    // hide method
    T* at(std::size_t);
};
 
}  // end namespace MeshLib