Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines class TypeDisplayer
       6             : 
       7             : #pragma once
       8             : 
       9             : #include "Utilities/TMPL.hpp"
      10             : 
      11             : /*!
      12             :  * \ingroup UtilitiesGroup TypeTraitsGroup
      13             :  * \brief Get compiler error with type of template parameter
      14             :  *
      15             :  * The compiler error generated when using an object of type
      16             :  * `TypeDisplayer<...>` contains the types of the template parameters. This
      17             :  * effectively provides printf-debugging for metaprogramming. For example,
      18             :  * \code
      19             :  * TypeDisplayer<std::vector<double>> some_random_name;
      20             :  * \endcode
      21             :  * will produce a compiler error that contains the type `std::vector<double,
      22             :  * std::allocator...>`. TypeDisplayer is extremely useful when debugging
      23             :  * template metaprograms.
      24             :  *
      25             :  * \note The TypeDisplayer header should only be included during testing
      26             :  * and debugging.
      27             :  *
      28             :  * \see make_list
      29             :  */
      30             : template <typename...>
      31           1 : struct TypeDisplayer;
      32             : 
      33             : /*!
      34             :  * \ingroup UtilitiesGroup
      35             :  * \brief Metafunction to turn a parameter pack into a typelist
      36             :  *
      37             :  * This metafunction is really only useful for debugging metaprograms. For
      38             :  * example, the desired algorithm might be:
      39             :  *
      40             :  * \code
      41             :  * using variables_tags_from_single_tags = tmpl::filter<
      42             :  *     extracted_from_variables,
      43             :  *     tmpl::bind<tmpl::found, tmpl::pin<mutated_tags_list>,
      44             :  *                tmpl::bind<std::is_same, tmpl::_1, tmpl::parent<tmpl::_1>>>>;
      45             :  * \endcode
      46             :  *
      47             :  * However, getting the `tmpl::pin`, `tmpl::parent`, and `tmpl::bind` calls
      48             :  * right can be extremely frustrating with little help as to what is going on.
      49             :  * Let's introduce an error by pinning `tmpl::_1`:
      50             :  *
      51             :  * \code
      52             :  * using variables_tags_from_single_tags = tmpl::filter<
      53             :  *     extracted_from_variables,
      54             :  *     tmpl::bind<tmpl::found, tmpl::pin<mutated_tags_list>,
      55             :  *                tmpl::bind<std::is_same, tmpl::pin<tmpl::_1>,
      56             :  *                tmpl::parent<tmpl::_1>>>>;
      57             :  * \endcode
      58             :  *
      59             :  * The result is comparing all values in `extracted_from_variables` to
      60             :  * themselves. To find this out, replace `tmpl::filter` and `tmpl::found` with
      61             :  * `tmpl::transform`, and the metafunction `std::is_same` to `make_list`.
      62             :  * You will then get back a "backtrace" of what the algorithm did, which is
      63             :  * invaluable for getting the `tmpl::pin` and `tmpl::parent` right. That is,
      64             :  *
      65             :  * \code
      66             :  * using variables_tags_from_single_tags2 = tmpl::transform<
      67             :  *     extracted_from_variables,
      68             :  *     tmpl::bind<tmpl::transform, tmpl::pin<mutated_tags_list>,
      69             :  *                tmpl::bind<make_list, tmpl::_1, tmpl::parent<tmpl::_1>>>>;
      70             :  *
      71             :  * TypeDisplayer<variables_tags_from_single_tags2> aeou;
      72             :  * \endcode
      73             :  *
      74             :  * You will get an output along the lines of:
      75             :  *
      76             :  * \code
      77             :  * src/DataStructures/DataBox.hpp:1181:40: error: implicit instantiation of
      78             :  * undefined template
      79             :  * 'TypeDisplayer<brigand::list<brigand::list<
      80             :  *     brigand::list<test_databox_tags::ScalarTag,
      81             :  *     test_databox_tags::Tag0>, brigand::list<test_databox_tags::ScalarTag,
      82             :  *     Tags::Variables<brigand::list<test_databox_tags::ScalarTag,
      83             :  *                     test_databox_tags::VectorTag> > > >,
      84             :  *     brigand::list<brigand::list<test_databox_tags::VectorTag,
      85             :  *                   test_databox_tags::Tag0>,
      86             :  *     brigand::list<test_databox_tags::VectorTag,
      87             :  *                   Tags::Variables<
      88             :  *                   brigand::list<test_databox_tags::ScalarTag,
      89             :  *                   test_databox_tags::VectorTag> > > > > >'
      90             :  * \endcode
      91             :  *
      92             :  * \see TypeDisplayer
      93             :  */
      94             : template <class... Ts>
      95           1 : struct make_list {
      96           0 :   using type = tmpl::list<Ts...>;
      97             : };