std::vector constructor from nlohmann::json vs. assignment

[billpriest]

All,
I converted some classes that used Poco::JSON to nlohmann::json and it sure is a lot "cleaner"; kudos to all. The classes use std::vector for some member vars and I noticed that the assignment from nlohmann::json to the std:vector didn't compile while the assignment at construction worked as expected.

1. Is this expected?
2. If I created a patch to add the assignment operator would it likely be accepted (assuming a minimal change set and all coding conventions followed)?

The vectors in question are quite large and I don't really want to create a copy just to then assign it to the member variable (obviously I can build the vector w/ a for loop and push_back as a fallback).

Thanks for a great package.

Bill

[falbrechtskirchinger]

Can you show some code? std::vector of what type? If it's not json the data is being copied already.

[billpriest]

#include "nlohmann/json.hpp"
#include
#include

using DVect = std::vector;
class Dummy
{
public:
Dummy() {}
DVect _dvect;
};
using Json=nlohmann::ordered_json;

int main()
{
Dummy dummy1;
dummy1._dvect.push_back(4.0);
dummy1._dvect.push_back(5.0);
dummy1._dvect.push_back(6.0);

Json j1;
j1["v1"] = dummy1._dvect;
std::cout << j1.dump() << std::endl;

#if 0
DVect d1 = j1["v1"];
std::cout << d1[0] << ", " << d1[1] << ", " << d1[2] << std::endl;
#else
Dummy dummy2;
dummy2._dvect = j1["v1"];
std::cout << dummy2._dvect[0] << ", " << dummy2._dvect[1] << ", " << dummy2._dvect[2] << std::endl;
#endif
return 0;
}

compiled with g++ -Wall -o dvect dvect.cc on x86-64 Linux g++ version 10.3

[billpriest]

Here is the compiler error
dvect.cc: In function ‘int main()’:
dvect.cc:29:28: error: ambiguous overload for ‘operator=’ (operand types are ‘DVect’ {aka ‘std::vector’} and ‘nlohmann::basic_jsonnlohmann::ordered_map::value_type’ {aka ‘nlohmann::basic_jsonnlohmann::ordered_map’})
29 | dummy2._dvect = j1["v1"];
| ^
In file included from /usr/include/c++/11/vector:72,
from /usr/include/c++/11/functional:62,
from /usr/include/c++/11/pstl/glue_algorithm_defs.h:13,
from /usr/include/c++/11/algorithm:74,
from /usr/local/include/nlohmann/json.hpp:46,
from dvect.cc:1:
/usr/include/c++/11/bits/vector.tcc:198:5: note: candidate: ‘std::vector<_Tp, _Alloc>& std::vector<_Tp, _Alloc>::operator=(const std::vector<_Tp, _Alloc>&) [with _Tp = double; _Alloc = std::allocator]’
198 | vector<_Tp, _Alloc>::
| ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/11/vector:67,
from /usr/include/c++/11/functional:62,
from /usr/include/c++/11/pstl/glue_algorithm_defs.h:13,
from /usr/include/c++/11/algorithm:74,
from /usr/local/include/nlohmann/json.hpp:46,
from dvect.cc:1:
/usr/include/c++/11/bits/stl_vector.h:709:7: note: candidate: ‘std::vector<_Tp, _Alloc>& std::vector<_Tp, _Alloc>::operator=(std::vector<_Tp, _Alloc>&&) [with _Tp = double; _Alloc = std::allocator]’
709 | operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
| ^~~~~~~~
/usr/include/c++/11/bits/stl_vector.h:730:7: note: candidate: ‘std::vector<_Tp, _Alloc>& std::vector<_Tp, _Alloc>::operator=(std::initializer_list<_Tp>) [with _Tp = double; _Alloc = std::allocator]’
730 | operator=(initializer_list<value_type> __l)
| ^~~~~~~~

[falbrechtskirchinger]

DVect d1 = j["v1"];

DVect d2;
d2 = DVect(j["v1"]);

Does this not work for you? Are you under the impression that this would be less efficient?

There's one additional heap allocation in the line DVect d2; and maybe one additional move operation, that the compiler should optimize away. That's going to be unavoidable if you insist on splitting initialization and assignment. Otherwise, under the hood, both assignments incur the same amount of work, i.e., in both cases a temporary DVect is constructed, space for j["v1"].size() elements is reserved, and elements are copied into the temporary DVect using std::transform, the temporary DVect is move assigned to the destination DVect (the destination DVect is created at a higher level and received by reference).

[gregmarr]

@billpriest Put at least 4 spaces at the start of each line of code so it's treated as code and the <> bits aren't filtered out.

As you are switching to the library, you really should use the option to disable implicit conversions. It's a safer method of working with the library, as it prevents some very surprising things from happening. https://github.com/nlohmann/json#implicit-conversions

DVect d1 = j1["v1"].get<std::vector<double>>();

Dummy dummy2;
dummy2._dvect = j1["v1"].get<std::vector<double>>();

[billpriest]

Agreed wrt changing to explicit; I already it an exception where the "type" was incorrectly deduced (web app sent # for an identifier which is really just a string).

Thanks to all for suggestions and advice. I figured I was "doing it wrong".

[billpriest]

So I implemented using the get<>() and it worked well except for one case where
getstd::string() on a field that could be a number but I always want to treat it as a string.
I got json.exception.type_error.302 type must be string, but is number
In this respect nlohmann::json works differently from Poco and Qt's json. I've coded around it by checking the type and converting it myself for the case where the field value is numeric.
"All fields are strings but not all fields are numbers"

[gregmarr]

In this respect nlohmann::json works differently from Poco and Qt's json. I've coded around it by checking the type and converting it myself for the case where the field value is numeric.

That's correct, it doesn't do any conversions between numbers and strings automatically.