backend/primitive/constant.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
0011 #include <covfie/core/concepts.hpp>
0012 #include <covfie/core/parameter_pack.hpp>
0013 #include <covfie/core/qualifiers.hpp>
0014 #include <covfie/core/utility/binary_io.hpp>
0015 #include <covfie/core/vector.hpp>
0016
0017 namespace covfie::backend {
0018 template <
0019     concepts::vector_descriptor _input_vector_t,
0020     concepts::vector_descriptor _output_vector_t>
0021 struct constant {
0022     using this_t = constant<_input_vector_t, _output_vector_t>;
0023     static constexpr bool is_initial = true;
0024
0025     using contravariant_input_t =
0026         typename covfie::vector::array_vector_d<_input_vector_t>;
0027     using covariant_output_t =
0028         typename covfie::vector::array_vector_d<_output_vector_t>;
0029
0030     struct owning_data_t;
0031
0032     using configuration_t = typename covariant_output_t::vector_t;
0033
0034     static constexpr uint32_t IO_MAGIC_HEADER = 0xAB010001;
0035
0036     struct owning_data_t {
0037         using parent_t = this_t;
0038
0039         owning_data_t() = default;
0040         owning_data_t(const owning_data_t &) = default;
0041         owning_data_t & operator=(const owning_data_t &) = default;
0042         owning_data_t & operator=(owning_data_t &&) = default;
0043
0044         explicit owning_data_t(configuration_t conf)
0045             : m_value(conf)
0046         {
0047         }
0048
0049         explicit owning_data_t(parameter_pack<configuration_t> && conf)
0050             : owning_data_t(std::move(conf.x))
0051         {
0052         }
0053
0054         explicit owning_data_t(parameter_pack<owning_data_t> && conf)
0055             : m_value(std::move(conf.x.m_value))
0056         {
0057         }
0058
0059         configuration_t get_configuration() const
0060         {
0061             return m_value;
0062         }
0063
0064         static owning_data_t read_binary(std::istream & fs)
0065         {
0066             utility::read_io_header(fs, IO_MAGIC_HEADER);
0067
0068             auto vec =
0069                 utility::read_binary<typename covariant_output_t::vector_t>();
0070
0071             utility::read_io_footer(fs, IO_MAGIC_HEADER);
0072
0073             return owning_data_t(vec);
0074         }
0075
0076         static void write_binary(std::ostream & fs, const owning_data_t & o)
0077         {
0078             utility::write_io_header(fs, IO_MAGIC_HEADER);
0079
0080             fs.write(
0081                 reinterpret_cast<const char *>(&o.m_value),
0082                 sizeof(decltype(o.m_value))
0083             );
0084
0085             utility::write_io_footer(fs, IO_MAGIC_HEADER);
0086         }
0087
0088         typename covariant_output_t::vector_t m_value;
0089     };
0090
0091     struct non_owning_data_t {
0092         using parent_t = this_t;
0093
0094         non_owning_data_t(const owning_data_t & o)
0095             : m_value(o.m_value)
0096         {
0097         }
0098
0099         COVFIE_HOST_DEVICE typename covariant_output_t::vector_t
0100             at(typename contravariant_input_t::vector_t) const
0101         {
0102             return m_value;
0103         }
0104
0105         typename covariant_output_t::vector_t m_value;
0106     };
0107 };
0108 }