PropertyVector.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 <cassert>
#include <iterator>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/view/common.hpp>
#include <string>
#ifdef _MSC_VER
#include <string_view>  // for MSVC, we need to include <string_view> to use std::string_view
#endif
#include <type_traits>
#include <utility>
#include <vector>
 
#include "BaseLib/Algorithm.h"
#include "MeshEnums.h"
 
namespace MeshLib
{
 
#ifdef _MSC_VER  // MSVC does not support inline variables until C++17, so we
                 // use a constexpr string_view instead of an inline variable.
inline constexpr std::string_view vtkGhostTypeString = "vtkGhostType";
#else
inline constexpr std::string vtkGhostTypeString = "vtkGhostType";
#endif
 
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 PropertyVectorBase
{
    friend class Properties;
 
public:
    using value_type = PROP_VAL_TYPE;
 
public:
    constexpr std::size_t getNumberOfTuples() const
    {
        return size() / _n_components;
    }

    PROP_VAL_TYPE& getComponent(std::size_t tuple_index, int component)
    {
        assert(component < _n_components);
        assert(tuple_index < getNumberOfTuples());
        return data_[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 data_[tuple_index * getNumberOfGlobalComponents() + component];
    }
 
    PropertyVectorBase* clone(
        std::vector<std::size_t> const& exclude_positions) const override
    {
        auto* cloned_pv = new PropertyVector<PROP_VAL_TYPE>(
            _property_name, _mesh_item_type, _n_components);
        cloned_pv->data_ = BaseLib::excludeObjectCopy(data_, exclude_positions);
        return cloned_pv;
    }

    constexpr std::size_t size() const { return data_.size(); }
 
    constexpr std::ptrdiff_t ssize() const { return std::ssize(data_); }
 
    // Same as begin, but semantically different; begin, end are pairs of
    // iterators, data returns raw pointer.
    constexpr const PROP_VAL_TYPE* data() const { return data_.data(); }
    constexpr PROP_VAL_TYPE* data() { return data_.data(); }
 
    constexpr PROP_VAL_TYPE* begin() { return data_.data(); }
    constexpr PROP_VAL_TYPE* end() { return data_.data() + data_.size(); }
 
    constexpr const PROP_VAL_TYPE* cbegin() const { return data_.data(); }
    constexpr const PROP_VAL_TYPE* cend() const
    {
        return data_.data() + data_.size();
    }
    constexpr const PROP_VAL_TYPE* begin() const { return cbegin(); }
    constexpr const PROP_VAL_TYPE* end() const { return cend(); }
 
    constexpr PROP_VAL_TYPE& operator[](std::size_t const pos)
    {
        if constexpr (std::is_same_v<PROP_VAL_TYPE, bool>)
        {
            static_assert(false,
                          "PropertyVector<bool>::operator[] cannot be "
                          "instantiated for booleans.");
        }
        else
        {
            return data_[pos];
        }
    }
    constexpr PROP_VAL_TYPE const& operator[](std::size_t const pos) const
    {
        if constexpr (std::is_same_v<PROP_VAL_TYPE, bool>)
        {
            static_assert(false,
                          "PropertyVector<bool>::operator[] cannot be "
                          "instantiated for booleans.");
        }
        else
        {
            return data_[pos];
        }
    }
 
    constexpr void resize(std::size_t const size) { data_.resize(size); }
    constexpr void resize(std::size_t const size, const PROP_VAL_TYPE& value)
    {
        data_.resize(size, value);
    }
 
    template <typename R>
        requires std::ranges::input_range<R> &&
                 std::convertible_to<std::ranges::range_value_t<R>,
                                     PROP_VAL_TYPE>
    constexpr void assign(R&& r)
    {
#if __cpp_lib_containers_ranges >= 202202L
        data_.assign_range(r);
#else
        if constexpr (ranges::common_range<R>)
        {
            data_.assign(r.begin(), r.end());
        }
        else
        {
            data_.assign(ranges::views::common(r).begin(),
                         ranges::views::common(r).end());
        }
#endif
    }
 
    constexpr void clear() { data_.clear(); }
    constexpr bool empty() const { return data_.empty(); }
 
protected:
    explicit PropertyVector(std::string const& property_name,
                            MeshItemType mesh_item_type,
                            std::size_t n_components)
        : 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)
        : PropertyVectorBase(property_name, mesh_item_type, n_components),
          data_(n_property_values * n_components)
    {
    }
 
private:
    std::vector<PROP_VAL_TYPE> data_;
};
 
static_assert(ranges::contiguous_range<PropertyVector<double>>);
static_assert(ranges::sized_range<PropertyVector<double>>);

template <typename T>
constexpr auto extend(PropertyVector<T>& property, std::size_t const count)
{
    std::size_t const offset = property.size();
    property.resize(offset + count);
    return property.begin() + offset;
}

template <typename T, typename R>
    requires ranges::sized_range<R> &&
             std::convertible_to<ranges::range_value_t<R>, T>
constexpr void appendValues(PropertyVector<T>& property, R&& values)
{
    ranges::copy(values, extend(property, ranges::size(values)));
}
}  // end namespace MeshLib