Provide a from_json overload for std::map

[theodelrieu]

This overload is chosen only when BasicJsonType::string_t
is not constructible from std::map::key_type.

Currently, converting a map to json treats it as an array of pairs.

fixes #1079

---

Pull request checklist

Read the Contribution Guidelines for detailed information.

• Changes are described in the pull request, or an existing issue is referenced.
• The test suite compiles and runs without error.
• Code coverage is 100%. Test cases can be added by editing the test suite.
• The source code is amalgamated; that is, after making changes to the sources in the include/nlohmann directory, run make amalgamate to create the single-header file single_include/nlohmann/json.hpp. The whole process is described here.

[theodelrieu]

@nlohmann Since we don't check extra values in the array when converting to std::pair, I'm doing the same thing.

(i.e. [1,2,3,4] -> std::pair {1, 2})

I'm wondering if we should check if the insertion in the map was successful, seems like a good idea. I don't know which exception to throw however. What's your opinion on it?

[coveralls]

Coverage remained the same at 100.0% when pulling c5e63fd on theodelrieu:feature/map_conversion into db03d09 on nlohmann:develop.

[nlohmann]

Sorry, I haven't found the time to look into this earlier.

[nlohmann]

The rest of the PR is OK, just one little test case would be nice.

[nlohmann]

Could you please also add a CHECK_THROWS_AS test?

[theodelrieu]

Done

[nlohmann]

I think the behavior is OK as you're right: it is consistent to the std::pair treatment. Adding an exception for std::map would also require adding one for std::pair which would mean a breaking change in terms of semantic versioning, right?

[nlohmann]

Looks good to me.

[theodelrieu]

Nothing is breaking, unless I missed something.

The std::pair overload is already there, and does not need to be changed. The issue with std::map is that its value_type is std::pair<**const** Key, Value>, so using the default std::pair overload does not work.

The only way that I know of constructing this peculiar value_type is to use std::map constructors/functions, so this special treatment is done inside the std::map overload.

Also, one can already serialize a std::map<int, int> to json, the other way around does not work though.

[nlohmann]

With "breaking" I meant the API behavior in case of superfluous list entries. As we do not throw for pairs if we convert from a 3-element list, we should not throw for maps for symmetry reasons. But adding an exception to the pairs would be a breaking change.

[theodelrieu]

Oh you're right, I've added a test case for this, I kept the existing behavior (i.e. discarding extra values from arrays)

[nlohmann]

Just for my understanding: Assume I have MyType and provided a to_json function. Then std::map<int, MyType> will be serialized to a list of pairs, and std::map<std::string, MyType> will be serialized to an object.

Assume I have AnotherType that can be converted to a std::string, e.g. by operator std::string(). Will a std::map<AnotherType, MyType be serialized to an object?

[theodelrieu]

Indeed, it will be serialized to an object.

The condition is: if string_t is constructible from Key, then it will be serialized to an object.

[nlohmann]

Thanks a lot!