Line data    Source code

       1            0 : // Distributed under the MIT License.
       2              : // See LICENSE.txt for details.
       3              : 
       4              : #pragma once
       5              : 
       6              : #include <string>
       7              : #include <vector>
       8              : 
       9              : #include "ControlSystem/Metafunctions.hpp"
      10              : #include "Utilities/Algorithm.hpp"
      11              : #include "Utilities/TMPL.hpp"
      12              : #include "Utilities/TypeTraits/IsA.hpp"
      13              : 
      14              : namespace control_system {
      15              : /*!
      16              :  * \brief Given a `tmpl::list` of control systems, returns a string which is a
      17              :  * sorted concatenation of all the control systems' names.
      18              :  *
      19              :  * \details As an example, if `ListOfControlSystems` is `tmpl::list<Rotation,
      20              :  * Expansion, Translation>`, this function would return
      21              :  * `ExpansionRotationTranslation`. Sorting is done using `std::sort`.
      22              :  *
      23              :  * \tparam ListOfControlSystems `tmpl::list` of control systems
      24              :  */
      25              : template <typename ListOfControlSystems>
      26            1 : const std::string& combined_name() {
      27              :   static const std::string combined_name = []() {
      28              :     std::vector<std::string> control_system_names{};
      29              :     control_system_names.reserve(tmpl::size<ListOfControlSystems>::value);
      30              :     std::string local_combined_name{};
      31              : 
      32              :     tmpl::for_each<ListOfControlSystems>(
      33              :         [&control_system_names](auto control_system_v) {
      34              :           using control_system = tmpl::type_from<decltype(control_system_v)>;
      35              :           control_system_names.emplace_back(control_system::name());
      36              :         });
      37              : 
      38              :     alg::sort(control_system_names);
      39              : 
      40              :     for (const std::string& name : control_system_names) {
      41              :       local_combined_name += name;
      42              :     }
      43              : 
      44              :     return local_combined_name;
      45              :   }();
      46              :   return combined_name;
      47              : }
      48              : 
      49              : /*!
      50              :  * \brief Given a `tmpl::list` of control systems, this returns a map between
      51              :  * the name of each control system, and the `control_system::combined_name` of
      52              :  * all control systems with the same measurement.
      53              :  *
      54              :  * \details All control systems have a type alias `measurement` corresponding to
      55              :  * a `control_system::protocols::Measurement`. Some control systems can have the
      56              :  * same measurement, while some have different ones. This function splits the
      57              :  * template list of control systems into a `tmpl::list` of `tmpl::list`s where
      58              :  * each inner list holds control systems with the same measurement. Each of
      59              :  * these inner lists is used in `control_system::combined_name` to get the
      60              :  * concatenated name for those control systems. This combined name is then used
      61              :  * as the value in the resulting map for they key of each control system in the
      62              :  * inner list.
      63              :  *
      64              :  * \tparam ControlSystems `tmpl::list` of control systems
      65              :  */
      66              : template <typename ControlSystems>
      67            1 : std::unordered_map<std::string, std::string> system_to_combined_names() {
      68              :   using measurements = metafunctions::measurements_t<ControlSystems>;
      69              :   using control_systems_with_measurements =
      70              :       tmpl::transform<measurements,
      71              :                       metafunctions::control_systems_with_measurement<
      72              :                           tmpl::pin<ControlSystems>, tmpl::_1>>;
      73              : 
      74              :   std::unordered_map<std::string, std::string> map_of_names{};
      75              : 
      76              :   tmpl::for_each<control_systems_with_measurements>([&map_of_names](
      77              :                                                         auto list_v) {
      78              :     using control_systems_with_measurement = tmpl::type_from<decltype(list_v)>;
      79              : 
      80              :     const std::string& combined_name =
      81              :         control_system::combined_name<control_systems_with_measurement>();
      82              : 
      83              :     tmpl::for_each<control_systems_with_measurement>(
      84              :         [&map_of_names, &combined_name](auto control_system_v) {
      85              :           using control_system = tmpl::type_from<decltype(control_system_v)>;
      86              :           map_of_names[control_system::name()] = combined_name;
      87              :         });
      88              :   });
      89              : 
      90              :   return map_of_names;
      91              : }
      92              : }  // namespace control_system