backend/transformer/dereference.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 <concepts::field_backend _backend_t>
0021 struct dereference {
0022     using this_t = dereference<_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<
0029         typename backend_t::covariant_output_t::vector_d>;
0030
0031     using configuration_t = std::monostate;
0032
0033     static constexpr uint32_t IO_MAGIC_HEADER = 0xAB020003;
0034
0035     struct owning_data_t {
0036         using parent_t = this_t;
0037
0038         owning_data_t() = default;
0039
0040         template <typename... Args>
0041         explicit owning_data_t(configuration_t, Args... args)
0042             : m_backend(std::forward<Args>(args)...)
0043         {
0044         }
0045
0046         explicit owning_data_t(parameter_pack<owning_data_t> && conf)
0047             : owning_data_t(std::move(conf.x))
0048         {
0049         }
0050
0051         template <typename... Args>
0052         explicit owning_data_t(parameter_pack<configuration_t, Args...> && args)
0053             : m_backend(std::move(args.xs))
0054         {
0055         }
0056
0057         explicit owning_data_t(
0058             const configuration_t &, typename backend_t::owning_data_t && b
0059         )
0060             : m_backend(b)
0061         {
0062         }
0063
0064         typename backend_t::owning_data_t & get_backend(void)
0065         {
0066             return m_backend;
0067         }
0068
0069         const typename backend_t::owning_data_t & get_backend(void) const
0070         {
0071             return m_backend;
0072         }
0073
0074         configuration_t get_configuration(void) const
0075         {
0076             return {};
0077         }
0078
0079         static owning_data_t read_binary(std::istream & fs)
0080         {
0081             auto be = decltype(m_backend)::read_binary(fs);
0082
0083             return owning_data_t(configuration_t{}, std::move(be));
0084         }
0085
0086         static void write_binary(std::ostream & fs, const owning_data_t & o)
0087         {
0088             decltype(m_backend)::write_binary(fs, o);
0089         }
0090
0091         typename backend_t::owning_data_t m_backend;
0092     };
0093
0094     struct non_owning_data_t {
0095         using parent_t = this_t;
0096
0097         non_owning_data_t(const owning_data_t & src)
0098             : m_backend(src.m_backend)
0099         {
0100         }
0101
0102         COVFIE_HOST_DEVICE typename covariant_output_t::vector_t
0103         at(typename contravariant_input_t::vector_t c) const
0104         {
0105             return m_backend.at(c);
0106         }
0107
0108         typename backend_t::non_owning_data_t & get_backend(void)
0109         {
0110             return m_backend;
0111         }
0112
0113         const typename backend_t::non_owning_data_t & get_backend(void) const
0114         {
0115             return m_backend;
0116         }
0117
0118         typename backend_t::non_owning_data_t m_backend;
0119     };
0120 };
0121 }