doxygen-c/html/static_8h_source.html

 #pragma once

 #include <torch/csrc/utils/variadic.h>
 #include <torch/types.h>

 #include <cstdint>
 #include <type_traits>

 namespace torch {
 namespace nn {
 class Module;
 } // namespace nn
 } // namespace torch

 namespace torch {
 namespace detail {
 template <typename T>
 struct has_forward {
   // Declare two types with differing size.
   using yes = int8_t;
   using no = int16_t;

   // Here we declare two functions. The first is only enabled if `&U::forward`
   // is well-formed and returns the `yes` type. In C++, the ellipsis parameter
   // type (`...`) always puts the function at the bottom of overload resolution.
   // This is specified in the standard as: 1) A standard conversion sequence is
   // always better than a user-defined conversion sequence or an ellipsis
   // conversion sequence. 2) A user-defined conversion sequence is always better
   // than an ellipsis conversion sequence This means that if the first overload
   // is viable, it will be preferred over the second as long as we pass any
   // convertible type. The type of `&U::forward` is a pointer type, so we can
   // pass e.g. 0.
   template <typename U>
   static yes test(decltype(&U::forward));
   template <typename U>
   static no test(...);

   // Finally we test statically whether the size of the type returned by the
   // selected overload is the size of the `yes` type.
   static constexpr bool value = (sizeof(test<T>(nullptr)) == sizeof(yes));
 };

 template <typename Head = void, typename... Tail>
 constexpr bool check_not_lvalue_references() {
   return (!std::is_lvalue_reference<Head>::value ||
           std::is_const<typename std::remove_reference<Head>::type>::value) &&
       check_not_lvalue_references<Tail...>();
 }

 template <>
 inline constexpr bool check_not_lvalue_references<void>() {
   return true;
 }

 template <typename M>
 using is_module =
     std::is_base_of<torch::nn::Module, typename std::decay<M>::type>;

 template <typename M, typename T = void>
 using enable_if_module_t =
     typename std::enable_if<is_module<M>::value, T>::type;
 } // namespace detail
 } // namespace torch
test
Definition: module.cpp:17

T
Definition: dataloader.cpp:482

torch::detail::has_forward
Detects if a type T has a forward() method.
Definition: static.h:19

detail
Definition: Dispatch.h:13

torch
Definition: jit_type.h:17