Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <type_traits>
       7             : 
       8             : #include "Utilities/TypeTraits.hpp"
       9             : 
      10             : namespace tt {
      11             : 
      12             : /*!
      13             :  * \ingroup ProtocolsGroup
      14             :  * \brief Indicate a class conforms to the `Protocol`.
      15             :  *
      16             :  * (Publicly) inherit classes from this class to indicate they conform to the
      17             :  * `Protocol`.
      18             :  *
      19             :  * \see Documentation on \ref protocols
      20             :  */
      21             : template <typename Protocol>
      22           1 : struct ConformsTo {};
      23             : 
      24             : // Note that std::is_convertible is used in the following type aliases as it
      25             : // will not match private base classes (unlike std::is_base_of)
      26             : 
      27             : /// @{
      28             : /*!
      29             :  * \ingroup ProtocolsGroup
      30             :  * \brief Checks if the `ConformingType` conforms to the `Protocol`.
      31             :  *
      32             :  * This metafunction is SFINAE-friendly. See `tt::assert_conforms_to` for a
      33             :  * metafunction that is not SFINAE-friendly but that triggers static asserts
      34             :  * with diagnostic messages to understand why the `ConformingType` does not
      35             :  * conform to the `Protocol`.
      36             :  *
      37             :  * This metafunction only checks if the class derives off the protocol to reduce
      38             :  * compile time. Protocol conformance is tested rigorously in the unit tests
      39             :  * instead.
      40             :  *
      41             :  * \see Documentation on \ref protocols
      42             :  * \see tt::assert_conforms_to
      43             :  */
      44             : template <typename ConformingType, typename Protocol>
      45           1 : struct conforms_to
      46             :     : std::is_convertible<ConformingType*, ConformsTo<Protocol>*> {};
      47             : template <typename ConformingType, typename Protocol>
      48           0 : constexpr bool conforms_to_v = conforms_to<ConformingType, Protocol>::value;
      49             : /// @}
      50             : 
      51             : /// @{
      52             : /*!
      53             :  * \ingroup ProtocolsGroup
      54             :  * \brief Assert that the `ConformingType` conforms to the `Protocol`.
      55             :  *
      56             :  * Similar to `tt::conforms_to`, but not SFINAE-friendly. Instead, triggers
      57             :  * static asserts with diagnostic messages to understand why the
      58             :  * `ConformingType` fails to conform to the `Protocol`.
      59             :  *
      60             :  * \see Documentation on \ref protocols
      61             :  * \see tt::conforms_to
      62             :  */
      63             : template <typename ConformingType, typename Protocol>
      64           1 : struct assert_conforms_to : std::true_type {
      65             :   static_assert(
      66             :       tt::conforms_to_v<ConformingType, Protocol>,
      67             :       "The type does not indicate it conforms to the protocol. The type is "
      68             :       "listed as the first template parameter to `assert_conforms_to` "
      69             :       "and the protocol is listed as the second template parameter. "
      70             :       "Have you forgotten to (publicly) inherit the type from "
      71             :       "tt::ConformsTo<Protocol>?");
      72             :   // Implicitly instantiate Protocol::test in order to test conformance
      73             :   static_assert(
      74             :       not std::is_same_v<
      75             :           decltype(typename Protocol::template test<ConformingType>{}), void>);
      76             : };
      77             : 
      78             : template <typename ConformingType, typename Protocol>
      79           0 : static constexpr bool assert_conforms_to_v =
      80             :     assert_conforms_to<ConformingType, Protocol>::value;
      81             : /// @}
      82             : 
      83             : }  // namespace tt