backend/transformer/covariant_cast.hpp

0001 /*
0002  * SPDX-PackageName: "covfie, a part of the ACTS project"
0003  * SPDX-FileCopyrightText: 2022 CERN
0004  * SPDX-License-Identifier: MPL-2.0
0005  */
0006
0007 #pragma once
0008
0009 #include <iostream>
0010 #include <variant>
0011
0012 #include <covfie/core/concepts.hpp>
0013 #include <covfie/core/definitions.hpp>
0014 #include <covfie/core/parameter_pack.hpp>
0015 #include <covfie/core/qualifiers.hpp>
0016 #include <covfie/core/utility/binary_io.hpp>
0017 #include <covfie/core/vector.hpp>
0018
0019 namespace covfie::backend {
0020 template <typename target_type, concepts::field_backend _backend_t>
0021 struct covariant_cast {
0022     using this_t = covariant_cast<target_type, _backend_t>;
0023     static constexpr bool is_initial = false;
0024
0025     using backend_t = _backend_t;
0026
0027     using contravariant_input_t = typename backend_t::contravariant_input_t;
0028     using covariant_output_t = vector::array_vector_d<vector::vector_d<
0029         target_type,
0030         backend_t::covariant_output_t::dimensions>>;
0031
0032     using configuration_t = std::monostate;
0033
0034     static constexpr uint32_t IO_MAGIC_HEADER = 0xAB020008;
0035
0036     struct owning_data_t {
0037         using parent_t = this_t;
0038
0039         owning_data_t() = default;
0040
0041         template <typename... Args>
0042         explicit owning_data_t(configuration_t, Args... args)
0043             : m_backend(std::forward<Args>(args)...)
0044         {
0045         }
0046
0047         explicit owning_data_t(parameter_pack<owning_data_t> && conf)
0048             : owning_data_t(std::move(conf.x))
0049         {
0050         }
0051
0052         template <typename... Args>
0053         explicit owning_data_t(parameter_pack<configuration_t, Args...> && args)
0054             : m_backend(std::move(args.xs))
0055         {
0056         }
0057
0058         explicit owning_data_t(
0059             const configuration_t &, typename backend_t::owning_data_t && b
0060         )
0061             : m_backend(b)
0062         {
0063         }
0064
0065         typename backend_t::owning_data_t & get_backend(void)
0066         {
0067             return m_backend;
0068         }
0069
0070         const typename backend_t::owning_data_t & get_backend(void) const
0071         {
0072             return m_backend;
0073         }
0074
0075         configuration_t get_configuration(void) const
0076         {
0077             return {};
0078         }
0079
0080         static owning_data_t read_binary(std::istream & fs)
0081         {
0082             auto be = decltype(m_backend)::read_binary(fs);
0083
0084             return owning_data_t(configuration_t{}, std::move(be));
0085         }
0086
0087         static void write_binary(std::ostream & fs, const owning_data_t & o)
0088         {
0089             decltype(m_backend)::write_binary(fs, o);
0090         }
0091
0092         typename backend_t::owning_data_t m_backend;
0093     };
0094
0095     struct non_owning_data_t {
0096         using parent_t = this_t;
0097
0098         non_owning_data_t(const owning_data_t & src)
0099             : m_backend(src.m_backend)
0100         {
0101         }
0102
0103         template <std::size_t... Is>
0104         COVFIE_HOST_DEVICE typename covariant_output_t::vector_t
0105         at_helper(typename contravariant_input_t::vector_t c, std::index_sequence<Is...>)
0106             const
0107         {
0108             return {static_cast<target_type>(m_backend.at(c)[Is])...};
0109         }
0110
0111         COVFIE_HOST_DEVICE typename covariant_output_t::vector_t
0112         at(typename contravariant_input_t::vector_t c) const
0113         {
0114             return at_helper(
0115                 c, std::make_index_sequence<contravariant_input_t::dimensions>{}
0116             );
0117         }
0118
0119         typename backend_t::non_owning_data_t & get_backend(void)
0120         {
0121             return m_backend;
0122         }
0123
0124         const typename backend_t::non_owning_data_t & get_backend(void) const
0125         {
0126             return m_backend;
0127         }
0128
0129         typename backend_t::non_owning_data_t m_backend;
0130     };
0131 };
0132 }