detect API version through sfinae - c++

Question

I work on a code base where the C++ API is about to change (master branch and feature branch) and I want to protect my code against the change, such that my code builds against both versions. As minimum working example godbolt/compiler-explorer link:
common:
class SmallWidget {
private:
int m_i;
public:
int i() { return m_i; }
};
master:
class BigWidget {
private:
std::vector<SmallWidget*> m_v;
public:
auto& widgets() { return m_v; }
};
feature branch:
class BigWidget {
private:
std::vector<SmallWidget> m_v;
public:
auto& widgets() { return m_v; }
};
/**/
For the master version I have some call code:
int single_op(BigWidget& w) {
return (*w.widgets().begin())->i(); // asterisk will need to go
}
std::vector<int> do_stuff(std::vector<BigWidget> inputs) {
std::vector<int> retval;
for (auto w : inputs) {
retval.push_back(single_op(w));
}
return retval;
}
The API does not come with a preprocessor variable to select with
#if WIDGET_VERSION == OLD
return (*w.widgets().begin())->i(); // asterisk will need to go
#else
return (w.widgets().begin())->i(); // asterisk gone
#endif
I was trying to detect the return type of widgets with sfinae:
// version for the master branch API
template <typename = typename std::enable_if<std::is_same<
std::remove_const<std::remove_reference<decltype(**(
std::declval<BigWidget>().widgets().begin()))>::type>::type,
SmallWidget>::value>::type>
int single_op(BigWidget& w) {
return (*w.widgets().begin())->i();
}
// version for the feature branch API
template <typename = typename std::enable_if<std::is_same<
std::remove_const<std::remove_reference<decltype(*(
std::declval<BigWidget>().widgets().begin()))>::type>::type,
SmallWidget>::value>::type>
int single_op(BigWidget& w) { return w.widgets().begin()->i(); }
But the compilers are not happy about that. clang says:
<source>:43:46: error: failed requirement 'std::is_same<std::remove_const<std::remove_reference<decltype(* (std::declval<BigWidget>().widgets().begin()))>::type>::type, SmallWidget>::value'; 'enable_if' cannot be used to disable this declaration
template
Is there a way to use sfinae to enable the right code here?
I also tried using std::enable_if for the return code or function arguments, but my understanding is that the compiler always sees the signature int single_op(BigWidget&) for both versions.

Answer 1

Create a small helper function that will take either type and return the type you want.
SmallWidget &getWidget(SmallWidget *w) { return *w; }
SmallWidget &getWidget(SmallWidget &w) { return w; }
int single_op(BigWidget &w) {
return getWidget(*w.widgets().begin()).i();
}
You can also provide overloads for const versions.

Answer 2

I could come up with this version:
// version for the feature branch API
template <typename bigtype>
int single_op(
typename std::enable_if<
std::is_same<
std::remove_const<std::remove_reference<decltype(
*(std::declval<BigWidget>().widgets().begin()))>::type>::type,
SmallWidget>::value,
bigtype>::type& w) {
return w.widgets().begin()->i();
}
I added one additional template argument for the BigWidget type (despite being known) and use it for the function argument of single_op. Now the compiler can go through both template definitions, arrive with one possible solution for the overload set and disables the unused code.
As drawback, I now have to spell out the template argument on the call side
retval.push_back(single_op<decltype(w)>(w));
But I suspect there are better solutions out there.