backend/primitive/identity.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 <type_traits>
0011 #include <variant>
0012
0013 #include <covfie/core/concepts.hpp>
0014 #include <covfie/core/parameter_pack.hpp>
0015 #include <covfie/core/utility/binary_io.hpp>
0016 #include <covfie/core/vector.hpp>
0017
0018 namespace covfie::backend {
0019 template <concepts::vector_descriptor _vector_t>
0020 struct identity {
0021     using this_t = identity<_vector_t>;
0022     static constexpr bool is_initial = true;
0023
0024     using contravariant_input_t = covfie::vector::array_vector_d<_vector_t>;
0025     using covariant_output_t = covfie::vector::array_vector_d<_vector_t>;
0026
0027     static_assert(
0028         contravariant_input_t::dimensions == covariant_output_t::dimensions,
0029         "Identity backend requires input and output to have identical "
0030         "dimensionality."
0031     );
0032     static_assert(
0033         std::is_constructible_v<
0034             typename contravariant_input_t::scalar_t,
0035             typename covariant_output_t::scalar_t>,
0036         "Identity backend requires type of input to be convertible to type of "
0037         "output."
0038     );
0039
0040     struct owning_data_t;
0041
0042     using configuration_t = std::monostate;
0043
0044     static constexpr uint32_t IO_MAGIC_HEADER = 0xAB010002;
0045
0046     struct owning_data_t {
0047         using parent_t = this_t;
0048
0049         explicit owning_data_t()
0050         {
0051         }
0052
0053         explicit owning_data_t(configuration_t)
0054         {
0055         }
0056
0057         explicit owning_data_t(parameter_pack<configuration_t> &&)
0058         {
0059         }
0060
0061         explicit owning_data_t(parameter_pack<owning_data_t> &&)
0062         {
0063         }
0064
0065         configuration_t get_configuration() const
0066         {
0067             return {};
0068         }
0069
0070         static owning_data_t read_binary(std::istream & fs)
0071         {
0072             utility::read_io_header(fs, IO_MAGIC_HEADER);
0073             utility::read_io_footer(fs, IO_MAGIC_HEADER);
0074
0075             return owning_data_t();
0076         }
0077
0078         static void write_binary(std::ostream & fs, const owning_data_t &)
0079         {
0080             utility::write_io_header(fs, IO_MAGIC_HEADER);
0081             utility::write_io_footer(fs, IO_MAGIC_HEADER);
0082         }
0083     };
0084
0085     struct non_owning_data_t {
0086         using parent_t = this_t;
0087
0088         non_owning_data_t(const owning_data_t &)
0089         {
0090         }
0091
0092         typename covariant_output_t::vector_t
0093         at(typename contravariant_input_t::vector_t c) const
0094         {
0095             typename covariant_output_t::vector_t rv;
0096
0097             for (std::size_t i = 0ul; i < contravariant_input_t::dimensions;
0098                  ++i)
0099             {
0100                 rv[i] = c[i];
0101             }
0102
0103             return rv;
0104         }
0105     };
0106 };
0107 }