I have a function template, and a class template:
template<typename T>
T testFunction(T argOne, T argTwo) { //Implementation }
template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
class testClass { //Implementation }
I want to limit the function to only accepting arithmetic types AND this one (though possibly more in the future) custom class template.
For just the arithmetic requirement this works fine:
template<typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
T testFunction(T argOne, T argTwo) { //Implementation }
but does not include the class template. So, I figured I'd simply make a custom type trait:
template<typename T>
constexpr bool is_valid_v = std::is_arithmetic_v<T> || std::is_same_v<T, testClass>;
template<typename T, std::enable_if_t<is_valid_v<T>, int> = 0>
T testFunction(T argOne, T argTwo) { //Implementation }
but this causes the compiler to complain with
use of class template 'testClass' requires template arguments
because it can't implicitly handle the type used for the template class when the trait template is declared this way. So, while the following compiles:
template<typename T>
constexpr bool is_valid_v = std::is_arithmetic_v<T> || std::is_same_v<T, testClass<int>> ||
std::is_same_v<T, testClass<long>> ||
std::is_same_v<T, testClass<float>> ||
//...;
template<typename T, std::enable_if_t<is_valid_v<T>, int> = 0>
T testFunction(T argOne, T argTwo) { //Implementation }
it is undesirable because I'd have to include a condition for every type the template class can use (everything under std::is_arithmetic).
I tried overloading the type trait like so:
template<typename T>
constexpr bool is_valid_v = std::is_arithmetic_v<T>;
template<template<typename> class T>
constexpr bool is_valid_v = std::is_same_v<T, NII>;
and while both of those compile fine, I still get
candidate template ignored: requirement 'is_valid_v<my_namespace::testClass<long, 0> >' was not satisfied [with T = my_namespace::testClass<long, 0>]
when trying to use testClass<long> (or any type) with testFunction.
How can I create a type trait constexpr with a "wildcard" so that I can achieve:
constexpr bool is_arithmetic_v = std::is_arithmetic_v<T> || std::is_same_v<T, NII<...>>;
without having to type out a case for every type testClass can be instantiated with? I'm fairly certain what I am aiming for is possible but that I just can't figure out the semantics for it.
EDIT: As @NathanOliver marked this post is almost a duplicate of Check if class is a template specialization? [duplicate]; however, that post doesn't show how to use its answer with enable_if and a custom template class. If I implement the answer in that post:
template <class T, template <class...> class Template>
struct is_specialization : std::false_type {};
template <template <class...> class Template, class... Args>
struct is_specialization<Template<Args...>, Template> : std::true_type {};
I can then modify my function template to be:
template<typename T, std::enable_if_t<is_specialization<T,std::vector>::value, int> = 0>
T testFunction(T argOne, T argTwo)
but as soon as I swap out std::vector with testClass I get:
error: template template argument has different template parameters than its corresponding template template parameter
Also, how can I create the shortcut is_specialization_v that makes use of ::value and returns a bool? I am unsure how to use the arguments provided in
template <template <class...> class Template, class...Args>
to achieve this.
EDIT 2:
The error with the solution in the other question seems to be because my class template has an enable_if statement itself. If I remove the requirement so it is just template<typename T> then testClass works in the is_specialization function. This won't work though because I need that enable condition on testClass.
These small, but significant differences (using all of these particular features at once) are why I asked this question and why it is not quite a duplicate.
