From b0c380b0f8f707995bdb5961a86e551c9ade3675 Mon Sep 17 00:00:00 2001 From: Niels Lohmann Date: Sun, 22 Oct 2017 09:12:35 +0200 Subject: [PATCH] :memo: cleanup after the last PRs --- README.md | 7 ++- src/json.hpp | 61 +++++++++++----------- test/src/unit-modifiers.cpp | 2 +- test/src/unit-readme.cpp | 6 +-- test/src/unit-reference_access.cpp | 82 +++++++++++++++--------------- test/src/unit-regression.cpp | 28 +++++----- 6 files changed, 97 insertions(+), 89 deletions(-) diff --git a/README.md b/README.md index 60611607f..90b5e3324 100644 --- a/README.md +++ b/README.md @@ -875,7 +875,12 @@ I deeply appreciate the help of the following people. - [WebProdPP](https://github.com/WebProdPP) fixed a subtle error in a precondition check. - [Alex](https://github.com/leha-bot) noted an error in a code sample. - [Tom de Geus](https://github.com/tdegeus) reported some warnings with ICC and helped fixing them. - +- [Perry Kundert](https://github.com/pjkundert) simplified reading from input streams. +- [Sonu Lohani](https://github.com/sonulohani) fixed a small compilation error. +- [Jamie Seward](https://github.com/jseward) fixed all MSVC warnings. +- [Nate Vargas](https://github.com/eld00d) added a Doxygen tag file. +- [pvleuven](https://github.com/pvleuven) helped fixing a warning in ICC. +- [Pavel](https://github.com/crea7or) helped fixing some warnings in MSVC. Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone. diff --git a/src/json.hpp b/src/json.hpp index 94d1c1e5d..cf1134a66 100644 --- a/src/json.hpp +++ b/src/json.hpp @@ -1404,63 +1404,66 @@ consist of all valid char values as positive values (typically unsigned char), plus an EOF value outside that range, specified by the value of the function std::char_traits::eof(). This value is typically -1, but could be any arbitrary value which is not a valid char value. - -@return Typically [0,255] plus std::char_traits::eof(). */ struct input_adapter_protocol { + /// get a character [0,255] or std::char_traits::eof(). virtual std::char_traits::int_type get_character() = 0; - virtual void unget_character() = 0; // restore the last non-eof() character to input + /// restore the last non-eof() character to input + virtual void unget_character() = 0; virtual ~input_adapter_protocol() = default; }; /// a type to simplify interfaces using input_adapter_t = std::shared_ptr; -/// input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at -/// beginning of input. Does not support changing the underlying std::streambuf -/// in mid-input. Maintains underlying std::istream and std::streambuf to -/// support subsequent use of standard std::istream operations to process any -/// input characters following those used in parsing the JSON input. Clears the -/// std::istream flags; any input errors (eg. EOF) will be detected by the first -/// subsequent call for input from the std::istream. +/*! +Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at +beginning of input. Does not support changing the underlying std::streambuf +in mid-input. Maintains underlying std::istream and std::streambuf to support +subsequent use of standard std::istream operations to process any input +characters following those used in parsing the JSON input. Clears the +std::istream flags; any input errors (e.g., EOF) will be detected by the first +subsequent call for input from the std::istream. +*/ class input_stream_adapter : public input_adapter_protocol { public: ~input_stream_adapter() override { - // clear stream flags; we use underlying streambuf I/O, do not maintain ifstream flags + // clear stream flags; we use underlying streambuf I/O, do not + // maintain ifstream flags is.clear(); } + explicit input_stream_adapter(std::istream& i) - : is(i) - , sb(*i.rdbuf()) + : is(i), sb(*i.rdbuf()) { - // Ignore Byte Order Mark at start of input + // ignore Byte Order Mark at start of input std::char_traits::int_type c; - if (( c = get_character() ) == 0xEF ) + if ((c = get_character()) == 0xEF) { - if (( c = get_character() ) == 0xBB ) + if ((c = get_character()) == 0xBB) { - if (( c = get_character() ) == 0xBF ) + if ((c = get_character()) == 0xBF) { return; // Ignore BOM } - else if ( c != std::char_traits::eof() ) + else if (c != std::char_traits::eof()) { is.unget(); } - is.putback( '\xBB' ); + is.putback('\xBB'); } - else if ( c != std::char_traits::eof() ) + else if (c != std::char_traits::eof()) { is.unget(); } - is.putback( '\xEF' ); + is.putback('\xEF'); } - else if ( c != std::char_traits::eof() ) + else if (c != std::char_traits::eof()) { - is.unget(); // Not BOM. Process as usual. + is.unget(); // Not BOM. Process as usual. } } @@ -1478,13 +1481,13 @@ class input_stream_adapter : public input_adapter_protocol void unget_character() override { - sb.sungetc(); // Avoided for performance: is.unget(); + sb.sungetc(); // is.unget() avoided for performance } - private: + private: /// the associated input stream std::istream& is; - std::streambuf &sb; + std::streambuf& sb; }; /// input adapter for buffer input @@ -2691,7 +2694,7 @@ scan_number_done: { ++chars_read; current = ia->get_character(); - if (JSON_LIKELY( current != std::char_traits::eof())) + if (JSON_LIKELY(current != std::char_traits::eof())) { token_string.push_back(std::char_traits::to_char_type(current)); } @@ -2709,7 +2712,7 @@ scan_number_done: token_string.pop_back(); } } - + /// add a character to yytext void add(int c) { @@ -2742,7 +2745,7 @@ scan_number_done: /// return current string value (implicitly resets the token; useful only once) std::string move_string() { - return std::move( yytext ); + return std::move(yytext); } ///////////////////// diff --git a/test/src/unit-modifiers.cpp b/test/src/unit-modifiers.cpp index dac361a56..01dfa4152 100644 --- a/test/src/unit-modifiers.cpp +++ b/test/src/unit-modifiers.cpp @@ -274,7 +274,7 @@ TEST_CASE("modifiers") // invalid values (no string/val pair) CHECK_THROWS_AS(j.push_back({1}), json::type_error&); CHECK_THROWS_WITH(j.push_back({1}), "[json.exception.type_error.308] cannot use push_back() with object"); - CHECK_THROWS_AS(j.push_back({1,2}), json::type_error&); + CHECK_THROWS_AS(j.push_back({1, 2}), json::type_error&); CHECK_THROWS_WITH(j.push_back({1, 2}), "[json.exception.type_error.308] cannot use push_back() with object"); CHECK_THROWS_AS(j.push_back({1, 2, 3, 4}), json::type_error&); CHECK_THROWS_WITH(j.push_back({1, 2, 3, 4}), "[json.exception.type_error.308] cannot use push_back() with object"); diff --git a/test/src/unit-readme.cpp b/test/src/unit-readme.cpp index 5a442c601..bc1597751 100644 --- a/test/src/unit-readme.cpp +++ b/test/src/unit-readme.cpp @@ -39,8 +39,8 @@ using nlohmann::json; #include #if defined(_MSC_VER) -#pragma warning (push) -#pragma warning (disable : 4189) // local variable is initialized but not referenced + #pragma warning (push) + #pragma warning (disable : 4189) // local variable is initialized but not referenced #endif TEST_CASE("README", "[hide]") @@ -305,5 +305,5 @@ TEST_CASE("README", "[hide]") } #if defined(_MSC_VER) -#pragma warning (pop) + #pragma warning (pop) #endif diff --git a/test/src/unit-reference_access.cpp b/test/src/unit-reference_access.cpp index 0066e24bd..c05ae7234 100644 --- a/test/src/unit-reference_access.cpp +++ b/test/src/unit-reference_access.cpp @@ -66,22 +66,22 @@ TEST_CASE("reference access") CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is object"); } SECTION("const reference access to const object_t") @@ -115,23 +115,23 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is array"); } SECTION("reference access to string_t") @@ -151,23 +151,23 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is string"); } SECTION("reference access to boolean_t") @@ -187,23 +187,23 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is boolean"); } SECTION("reference access to number_integer_t") @@ -223,23 +223,23 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); } SECTION("reference access to number_unsigned_t") @@ -259,23 +259,23 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); //CHECK_THROWS_AS(value.get_ref(), json::type_error&); //CHECK_THROWS_WITH(value.get_ref(), // "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_NOTHROW(value.get_ref()); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); } SECTION("reference access to number_float_t") @@ -295,22 +295,22 @@ TEST_CASE("reference access") // check if mismatching references throw correctly CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_THROWS_AS(value.get_ref(), json::type_error&); CHECK_THROWS_WITH(value.get_ref(), - "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); + "[json.exception.type_error.303] incompatible ReferenceType for get_ref, actual type is number"); CHECK_NOTHROW(value.get_ref()); } } diff --git a/test/src/unit-regression.cpp b/test/src/unit-regression.cpp index 2d30a52c5..4942d3151 100644 --- a/test/src/unit-regression.cpp +++ b/test/src/unit-regression.cpp @@ -1236,21 +1236,21 @@ TEST_CASE("regression tests") SECTION("issue #367 - Behavior of operator>> should more closely resemble that of built-in overloads.") { - SECTION("example 1") - { - std::istringstream i1_2_3( "{\"first\": \"one\" }{\"second\": \"two\"}3" ); - json j1, j2, j3; - i1_2_3 >> j1; - i1_2_3 >> j2; - i1_2_3 >> j3; + SECTION("example 1") + { + std::istringstream i1_2_3( "{\"first\": \"one\" }{\"second\": \"two\"}3" ); + json j1, j2, j3; + i1_2_3 >> j1; + i1_2_3 >> j2; + i1_2_3 >> j3; - std::map m1 = j1; - std::map m2 = j2; - int i3 = j3; + std::map m1 = j1; + std::map m2 = j2; + int i3 = j3; - CHECK( m1 == ( std::map {{ "first", "one" }} )); - CHECK( m2 == ( std::map {{ "second", "two" }} )); - CHECK( i3 == 3 ); - } + CHECK( m1 == ( std::map {{ "first", "one" }} )); + CHECK( m2 == ( std::map {{ "second", "two" }} )); + CHECK( i3 == 3 ); + } } }