How to test if a struct contains specific members by SFINAE - c++

Question

In order to define overloaded functions to parse an input string to specific data type, I do like below:
#include <type_traits>
// /std:c++17 enabled
template <class T>
constexpr bool is_point_v = std::is_class_v<T> && !std::is_enum_v<T>
&& std::is_arithmetic_v<decltype(T::x)>
&& std::is_arithmetic_v<decltype(T::y)>
&& (sizeof(T) == sizeof(T::y) + sizeof(T::y));
template <class T>
constexpr bool is_rect_v = std::is_class_v<T> && !std::is_enum_v<T>
&& std::is_arithmetic_v<decltype(T::left)>
&& std::is_arithmetic_v<decltype(T::top)>
&& std::is_arithmetic_v<decltype(T::right)>
&& std::is_arithmetic_v<decltype(T::bottom)>
&& (sizeof(T) == sizeof(T::left) + sizeof(T::top) + sizeof(T::right) + sizeof(T::bottom));
template<typename T>
struct Point {
std::enable_if_t<std::is_arithmetic_v<T>, T>
x {}, y {};
Point() noexcept {}
};
template<typename T>
struct Rect {
std::enable_if_t<std::is_arithmetic_v<T>, T>
left {}, top {}, right {}, bottom {};
Rect() noexcept {}
};
class DBParser
{
public:
template <typename T>
typename std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>, T>
get(const char* key, T defaultValue = {}) {
// ...
return defaultValue;
}
template <typename T>
typename std::enable_if_t<is_point_v<T>, T>
get(const char* key, T defaultValue = {}) {
// ...
return defaultValue;
}
template <typename T>
typename std::enable_if_t<is_rect_v<T>, T>
get(const char* key, T defaultValue = {}) {
// ...
return defaultValue;
}
};
int main()
{
DBParser db;
auto point1 = db.get<Point<int>>("point1", {});
auto point2 = db.get<Point<float>>("point2", {});
auto rect1 = db.get<Rect<int>>("rect1", {});
auto rect2 = db.get<Rect<float>>("rect2", {});
auto ret3 = db.get<int>("key3", {});
}
Compiling the code above gives a tone of errors. Obviously the SFINAE I did for the functions "get" are incorrect and somewhat clumsy but I could not figure it out.
Could you give me some fixes for the code? In the case C++17 could not make the code less verbose, I accept C++20.
UPDATE:
In order to make the question is more appropriate to the issue, I want to change the title and add more information.
One thing strange is if I put the testing of struct directly to the functions like this:
template <class T>
std::enable_if_t < std::is_class_v<T> && !std::is_enum_v<T>
&& std::is_arithmetic_v<decltype(T::x)>
&& std::is_arithmetic_v<decltype(T::y)>
&& (sizeof(T) == sizeof(decltype(T::x)) + sizeof(decltype(T::y))), T>
get(const char* key, T defaultValue) { // Point
return defaultValue;
}
It get compiled without errors. So I think the assumption from Nicol Bolas may be not correct.