why type errors in runtime

[VadimZy]

Why does this implementation move all the type errors in runtime? is this in C++?

[nlohmann]

Can you give an example? I have an idea what you mean, but I don't want to answer with "Because JSON" without knowing exactly what you expect.

[falbrechtskirchinger]

Show your code.

Edit: This error can only be triggered with type_deduction=false, meaning your initializer list doesn't describe an object, which is most certainly a user error.

[VadimZy]

  j.push_back("rs");

	auto &jrs = j.back();
	jrs["name"] = p.first;

[VadimZy]

no doubt this is a user error but it still does not excuse not reporting it in compile time

[falbrechtskirchinger]

I don't believe any of those lines could throw that exception. Please provide a complete (i.e., compilable and executable) example that replicates the issue.

[falbrechtskirchinger]

no doubt this is a user error but it still does not excuse not reporting it in compile time

That's not possible, so there's nothing to excuse.

[VadimZy]

centos 7
gcc --version
gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44)
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

		nlohmann::json js;
		js["bar"] = 23;
		js["foo"] = 42;
		//js.emplace("test", "dump");

		print_stats(source_idx, js);
....

print_stats(std::size_t source_idx, nlohmann::json& j)
{
	//auto rs = find_source(source_idx)->ruleset;
	//for (const auto &p : m_known_rulesets)
	//{
		j.push_back("rs");
		auto &jrs = j.back();
		jrs["name"] = p.first;
		//rs->get_stats(p.second, jrs);
		j.push_back({"rs", jrs});
	//}
}

[falbrechtskirchinger]

I need a minimal example to copy, paste, compile, and execute.

What version of the library are you using?

[VadimZy]

/*
__ _____ _____ _____
| | | | | | JSON for Modern C++
| | | | | | | | | version 3.3.0
|||_||| https://github.com/nlohmann/json

void main (...)
nlohmann::json js;
		js["bar"] = 23;
		js["foo"] = 42;
		//js.emplace("test", "dump");

		print_stats(source_idx, js);
}

print_stats(std::size_t source_idx, nlohmann::json& j)
{
	//auto rs = find_source(source_idx)->ruleset;
	//for (const auto &p : m_known_rulesets)
	//{
		j.push_back("rs");
		auto &jrs = j.back();
		jrs["name"] = p.first;
		//rs->get_stats(p.second, jrs);
		j.push_back({"rs", jrs});
	//}
}

that should do

[falbrechtskirchinger]

Fails with:

terminate called after throwing an instance of 'nlohmann::detail::type_error'
  what():  [json.exception.type_error.308] cannot use push_back() with object

(p.first is undefined and I had to remove that line.)

[VadimZy]

I am struggling with a simple thing - to append an object (emplace) with a giving name and pass its ref to the next stage.
none of push_back, emplace, insert seem to be suitable.

[falbrechtskirchinger]

What's wrong with this?

j["rs"] = jrs;

[VadimZy]

the wrong is the existence of the temp object: jrs

		auto jrs = nlohmann::json::object();
		jrs["name"] = p.first;
		rs->get_stats(p.second, jrs);
		j["rs"] = jrs;

[falbrechtskirchinger]

Here are 3 options:

auto &jrs = j["rs"];
jrs["name"] = p.first; // this works because null converts to object
rs->get_stats(p.second, jrs);

auto jrs = nlohmann::json::object();
jrs["name"] = p.first;
rs->get_stats(p.second, jrs);
j["rs"] = std::move(jrs);

auto res = j.emplace("rs", nlohmann::json::object());
(*res.first)["name"] = p.first;
rs->get_stats(p.second, *res.first);

[VadimZy]

again, these all should be compile-time errors:
Hit a std exception [json.exception.type_error.305] cannot use operator[] with a string argument with array

[VadimZy]

		std::string out;
		for (auto b = js.begin(), e =js.end(); b != e; ++b )
		{
			out += *b;
			out += "\n";
		}

Hit a std exception [json.exception.type_error.302] type must be string, but is number
C++ is not Python or JavaScript

[VadimZy]

in a good C++ if it compiles it works

[VadimZy]

all should be strongly typed

[ichenglin]

There's no such thing as "if it compiles it works",
there are too many factors that couldn't be considered during the compilation process.

[falbrechtskirchinger]

basic_json stores any valid JSON type and which type is stored is not known until runtime (and cannot be known in the general case).
If you don't want type errors to be thrown, you have to program more defensively and verify that basic_json instances hold the expected type for an operation.
After all, C++ IS strongly typed, that's why these operations have to fail at some point (i.e., runtime).