::get<int>() fails in new(er) release [MSVC]

[sfinktah]

Compiler: MSVC 15.1 (2017) with VS2015 libraries etc.

Was working with: c42273d (2.1.1)

    hsv_t(const json &values)
        : hsv_t( 
            wrap360( values[0].get<int>()),
            clamp100(values[1].get<int>()),
            clamp100(values[2].get<int>()),
            clamp100(values[3].get<int>())){}

Fails with: d300a8e (2.1.1) latest dev

Replaced with:
    hsv_t(const json &values)
        : hsv_t( 
            wrap360( static_cast<int>(values[0])),
            clamp100(static_cast<int>(values[1])),
            clamp100(static_cast<int>(values[2])),
            clamp100(static_cast<int>(values[3]))){}

But error just moved to json.hpp +9836

    template < typename ValueType, typename std::enable_if <
                   not std::is_pointer<ValueType>::value and
                   not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
                   not std::is_same<ValueType, typename string_t::value_type>::value
#ifndef _MSC_VER  // fix for issue #167 operator<< ambiguity under VS2015
                   and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
#endif
#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_MSC_VER) && _MSC_VER >1900 && defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
                   and not std::is_same<ValueType, typename std::string_view>::value
#endif
                   , int >::type = 0 >
    operator ValueType() const
    {
        // delegate the call to get<>() const
        return get<ValueType>();
    }

1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9836): error C2672: 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get': no matching overloaded function found
1>e:\git\infamous-dll\src\Update/Types.h(333): note: see reference to function template instantiation 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::operator ValueType(void) const<float,0>' being compiled
1>        with
1>        [
1>            ValueType=float
1>        ]
1>e:\git\infamous-dll\src\Update/Types.h(333): note: see reference to function template instantiation 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::operator ValueType(void) const<float,0>' being compiled
1>        with
1>        [
1>            ValueType=float
1>        ]
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9836): error C2783: 'const PointerType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept const': could not deduce template argument for '__formal'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9663): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9836): error C2783: 'PointerType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept': could not deduce template argument for '__formal'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9651): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9836): error C2783: 'ValueType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept(<expr>) const': could not deduce template argument for '__formal'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9614): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9836): error C2783: 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer> nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) const': could not deduce template argument for '__formal'
1>E:\git\infamous-dll\src\vendor\sfinktah\include\json.hpp(9509): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'

[nlohmann]

How does values look like? Does the error still occur with the latest develop version?

[sfinktah]

that is the latest develop version.

* develop d300a8e :rotating_light: fixed warnings #776

values is just an array of 4 numbers, nothing special. but this is all compile time, so the actual contents of values is only hypothetical.

sorry, forgot to add that the function is a class constructor.

the main reason I updated from the previous release I was running, is that I couldn't serialize BYTE (__uint8) or obvious char/__int8 values. But I thought it best to see if that had been addresses in a more recent commit before searching issues.

[sfinktah]

Here's a complete-ish copy of the class header:

struct hsv_t {
    int h;
    int s;
    int v;
    int a;

    constexpr hsv_t() : h(0), s(0), v(0), a(0) {}
    constexpr hsv_t(int h, int s, int v, int a) : h(wrap360(h)), s(clamp100(s)), v(clamp100(v)), a(clamp255(a)){}
    constexpr hsv_t(int h, int s, int v) : hsv_t(h, s, v, 255) {}
    constexpr hsv_t(float h, float s, float v) : hsv_t(h * 360, s * 100, v * 100, 255) {}

    template<typename T>
    constexpr hsv_t(T (&values)[3])
        : hsv_t( 
            static_cast<int>(values[0]), 
            static_cast<int>(values[1]), 
            static_cast<int>(values[2])){}

    template<typename T>
    constexpr hsv_t(T (&values)[4])
        : hsv_t( 
            static_cast<int>(values[0]), 
            static_cast<int>(values[1]), 
            static_cast<int>(values[2]), 
            static_cast<int>(values[3])){}

    template<typename T>
    constexpr hsv_t(std::array<T, 4> values)
        : hsv_t( 
            static_cast<int>(values[0]), 
            static_cast<int>(values[1]), 
            static_cast<int>(values[2]), 
            static_cast<int>(values[3])){}

    hsv_t(const json &values)
        : hsv_t( 
            wrap360( values[0].get<int>()),
            clamp100(values[1].get<int>()),
            clamp100(values[2].get<int>()),
            clamp100(values[3].get<int>())){}

There's probably a fancy way to cast the json array as a std::container, but it eludes me.

I should add, that this isn't the only place the error occurred, simply the first place. I can make you a test project for MSVC if you like.

[nlohmann]

What is clamp100 and wrap360?

[sfinktah]

LOL, I really should have looked for a simpler instance, in-fact, I will do exactly that. It's dealing with the HSV color palette, so wrap360 wraps around 360°, and clamp is ... a clamp.

template <typename T>
constexpr uint8_t clamp100(T val) {
    #define MIN 0
    #define MAX 100
    return (
        val > MAX ? MAX :
        val < MIN ? MIN :
        val
    );
    #undef MIN
    #undef MAX
}

template <typename T>
constexpr uint16_t wrap360(T val) {
    #define MIN 0
    #define MAX 360
    return (
        (val + MAX) % MAX
    );
    #undef MIN
    #undef MAX
}

I did find out something new though -- because the constructor taking json arguments isn't marked explicit, there was an edge case where

    std::vector<int> v{1, 2, 3};
    rgb_t color = rgb_t(v);

was passed through the json constructor.

The constructor is marked explicit now.

[sfinktah]

Hmmm.... turns out, there is no simpler instance of it failing. Just the hsv_t and a similar rgb_t struct.

I did remove the misc. clamps, and such, and used the original json::get<int> syntax. The errors may be different, and plausibly enlightening. (Though not for me, I'm afraid).

    explicit hsv_t(const json &values)
        : hsv_t( 
            values[0].get<int>(),
            values[1].get<int>(),
            values[2].get<int>(),
            values[3].get<int>()
		){}

The errors are repeated for each of the 4 lines of the constructor.

1>Types.h(1141):  error C2672: 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get': no matching overloaded function found
1>Types.h(1141):  error C2783: 'const PointerType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept const': could not deduce template argument for '__formal'
1>json.hpp(9663): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>Types.h(1141):  error C2783: 'PointerType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept': could not deduce template argument for '__formal'
1>json.hpp(9651): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>Types.h(1141):  error C2783: 'ValueType nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) noexcept(<expr>) const': could not deduce template argument for '__formal'
1>json.hpp(9614): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'
1>Types.h(1141):  error C2783: 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer> nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get(void) const': could not deduce template argument for '__formal'
1>json.hpp(9509): note: see declaration of 'nlohmann::basic_json<std::map,std::vector,std::string,bool,int64_t,uint64_t,double,std::allocator,nlohmann::adl_serializer>::get'

I was especially thrown by could not deduce template argument for '__formal' ...

[sfinktah]

Okay, I went hunting for other occurrences of .get<> and checked for Intellisense (shudder) errors.

These weren't immediately apparent, because the compiler halts after the errors above.

"No instance of overloaded function basic_json... matches the argument list. Object type is: json"

        if (j.is_string()) {
            result = getTextFromLabel(ptr, j.get<std::string>().c_str());

"No instance of overloaded function basic_json... matches the argument list. Object type is: basic_json<std::map ... adl_serializer>"

for (int ii = 0; ii < a.size(); ii++) {
	// Let keep it simple for demonstration purposes:
	printf("%i", a[ii].get<int>());
}

[theodelrieu]

This is very strange, I've seen some projects like sqlpp11 that were broken by the latest MSVC 2017 release...

Might it be the case here?

[sfinktah]

Just tested a compile using the 2015 command line tools, same result.

Interestingly, a quick test program which should have caused the same error, compiled without issue.

confused

#include "json.hpp"
using json = nlohmann::json;

int main(int argc, char **argv) {
    json j = { {"list", {1, 0, 2} } };

    json j2 = j["list"];
    auto item = j2[1].get<int>();
}

A quick google search on the error message produced (apart from this issue) an article about constexpr causing issues.

https://social.msdn.microsoft.com/Forums/windowsdesktop/en-US/9c04ff5b-b542-4b84-80d3-6d65159becbc/type-deduction-failure-when-using-a-constexpr-function?forum=vclanguage

[nlohmann]

This really sounds like a bug. Did you try (just to make sure) to remove the constexpr from your code and see if it compiles then?

[theodelrieu]

From your snippet, it seems like there's a bug in your macro.

Did you forget the double quotes?

j["#X"]

[gregmarr]

No, #X makes X into a quoted string.

[nlohmann]

I am not sure whether I can help with #780 (comment), especially without knowing how SavedVehicleModDBRow looks like.