field.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022-2023 Dennis Gläser <dennis.glaeser@iws.uni-stuttgart.de>
// SPDX-License-Identifier: MIT
#ifndef GRIDFORMAT_COMMON_FIELD_HPP_
#define GRIDFORMAT_COMMON_FIELD_HPP_
 
#include <memory>
#include <cstddef>
#include <concepts>
#include <type_traits>
#include <utility>
#include <ranges>
#include <cmath>
#include <string>
 
#include <gridformat/common/md_layout.hpp>
#include <gridformat/common/precision.hpp>
#include <gridformat/common/serialization.hpp>
#include <gridformat/common/type_traits.hpp>
#include <gridformat/common/exceptions.hpp>
#include <gridformat/common/concepts.hpp>
#include <gridformat/common/ranges.hpp>
 
namespace GridFormat {


class Field {
 public:
    static constexpr struct DisableResize {} no_resize{};
 
    virtual ~Field() = default;
 
    Field() = default;
    Field(Field&&) = default;
    Field(const Field&) = delete;
    Field& operator=(Field&&) = default;
    Field& operator=(const Field&) = delete;

    MDLayout layout() const {
        return _layout();
    }

    DynamicPrecision precision() const {
        return _precision();
    }

    std::size_t size_in_bytes() const {
        return layout().number_of_entries()*precision().size_in_bytes();
    }

    Serialization serialized() const {
        auto result = _serialized();
        if (result.size() != size_in_bytes())
            throw SizeError("Serialized size does not match expected number of bytes");
        return result;
    }

    template<typename Visitor>
    decltype(auto) visit_field_values(Visitor&& visitor) const {
        return precision().visit([&] <typename T> (const Precision<T>&) {
            const auto serialization = serialized();
            return visitor(serialization.template as_span_of<T>());
        });
    }

    template<std::ranges::range R> requires(Concepts::Scalar<MDRangeValueType<R>>)
    decltype(auto) export_to(R&& output_range) const {
        if constexpr (std::same_as<std::remove_cvref_t<R>, std::string>) {
            decltype(auto) result = _export_to<true>(std::forward<R>(output_range));
            if (!result.empty() && result.back() == '\0')
                result.pop_back();
            if (result.find('\0') != std::string::npos)
                throw ValueError("Field holds multiple strings, export it into a MultiString instead");
            return std::forward<decltype(result)>(result);
        } else {
            return _export_to<true>(std::forward<R>(output_range));
        }
    }

    template<std::ranges::range R> requires(Concepts::Scalar<MDRangeValueType<R>>)
    decltype(auto) export_to(R&& output_range, DisableResize) const {
        return _export_to<false>(std::forward<R>(output_range));
    }

    template<Concepts::Scalar S>
    void export_to(S& out) const {
        const auto my_layout = layout();
        const auto serialization = serialized();
        if (my_layout.number_of_entries() != 1)
            throw TypeError("Field cannot be exported into a scalar");
        visit_field_values([&] <typename T> (std::span<const T> data) {
            out = static_cast<S>(data[0]);
        });
    }

    template<Concepts::Scalar S>
    S export_to() const {
        S out;
        export_to(out);
        return out;
    }

    template<Concepts::ResizableMDRange R>
        requires(Concepts::StaticallySizedMDRange<std::ranges::range_value_t<R>> or
                 Concepts::Scalar<std::ranges::range_value_t<R>>)
    R export_to() const {
        return export_to(R{});
    }
 
 private:
    DynamicPrecision _prec;
 
    virtual MDLayout _layout() const = 0;
    virtual DynamicPrecision _precision() const = 0;
    virtual Serialization _serialized() const = 0;

    template<bool enable_resize, std::ranges::range R> requires(Concepts::Scalar<MDRangeValueType<R>>)
    decltype(auto) _export_to(R&& output_range) const {
        const auto my_layout = layout();
 
        if constexpr (Concepts::ResizableMDRange<R> && enable_resize) {
            const auto num_scalars = my_layout.number_of_entries();
            const auto num_sub_scalars = get_md_layout<std::ranges::range_value_t<R>>().number_of_entries();
            if (num_scalars%num_sub_scalars != 0)
                throw TypeError(
                    "Cannot export the field into the given range type. "
                    "Number of entries in the field is not divisible by the "
                    "number of entries in the value_type of the provided range."
                );
 
            output_range.resize(
                num_scalars/num_sub_scalars,
                DefaultValue<std::ranges::range_value_t<R>>::get()
            );
        } else {
            const auto output_range_layout = get_md_layout(output_range);
            if (output_range_layout.number_of_entries() < my_layout.number_of_entries())
                throw SizeError(
                    std::string{"Cannot fill the given range. Too few entries. "} +
                    "Number of field entries: '" + std::to_string(my_layout.number_of_entries()) + "'; " +
                    "Number of range entries: '" + std::to_string(output_range_layout.number_of_entries()) + "'"
                );
        }
 
        std::size_t offset = 0;
        visit_field_values([&] <typename T> (std::span<const T> data) {
            _export_to(output_range, data, offset);
        });
 
        return std::forward<R>(output_range);
    }
 
    template<std::ranges::range R, Concepts::Scalar T>
    void _export_to(R& range,
                    std::span<const T> data,
                    std::size_t& offset) const {
        if constexpr (mdrange_dimension<R> > 1) {
            std::ranges::for_each(range, [&] (std::ranges::range auto& sub_range) {
                _export_to(sub_range, data, offset);
            });
        } else {
            // Note: if the span is over a std::vector<bool>, the use of `std::ranges::copy` or similar broke here.
            //       It seems to work with more recent compilers and/or c++23, though. We use `std::copy` as a workaround.
            auto converted_data = data | std::views::drop(offset)
                                       | std::views::take(std::min(Ranges::size(range), data.size() - offset))
                                       | std::views::transform([] (const T& value) {
                                            return static_cast<std::ranges::range_value_t<R>>(value);
                                        });
            std::copy(
                std::ranges::begin(converted_data),
                std::ranges::end(converted_data),
                std::ranges::begin(range)
            );
            offset += Ranges::size(converted_data);
        }
    }
};

using FieldPtr = std::shared_ptr<const Field>;

template<typename F> requires(
    std::derived_from<std::remove_cvref_t<F>, Field> and
    !std::is_lvalue_reference_v<F>)
FieldPtr make_field_ptr(F&& f) {
    return std::make_shared<std::add_const_t<F>>(std::forward<F>(f));
}

 
}  // namespace GridFormat
 
#endif  // GRIDFORMAT_COMMON_FIELD_HPP_