Please consider to change this, otherwise if you include the library like this:

add_subdirectory(external/json11) set(JSON11_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/json11) set(JSON11_LIBRARIES json11)

it will work but if you run make install on your project it cannot find the json11.hpp and json11.pc file, because it searches in the wrong build directory.

Also double check if this might cause trouble with other configuration. I haven't experienced side effects.

I know that comments are not defined in json standard, but many parsers do support them, and I find them useful. the patch is activated by a preprocessor macro and the original behavior can be restored by commenting its definition.

If you have compile options set to throw a compile error on floating point comparison then there is trouble here:

I don't know a suitable template specialization that works here. That does mean there is not one. https://github.com/dropbox/json11/blob/master/json11.cpp#L163

This needs an "epsilon" comparison. https://github.com/dropbox/json11/blob/master/json11.cpp#L176

and on the int templated https://github.com/dropbox/json11/blob/master/json11.cpp#L185 which is strange but easy to fix with a type cast.

Will submit a PR if I find a good fix for everything.

When trying to build JSON11 on Microsoft Visual Studio 14 2015, the compiler would complain about the -Wextra and -Werror flags.

This PR adds a check for the C++ compiler before adding the compiler specific flags

Issue for tracking a long-standing issue which was never tracked publicly before. It's natural to want to construct a nested JSON array as follows: Json nested_array = Json::array { Json::array { 1, 2, 3 } }; This used to work as expected, until a language standard change DR1467 which caused the array constructor to be interpreted as a move instead of creating a nested array from an initializer_list. This is only an issue for single-element arrays, since 2 elements would break the ambiguity and be interpreted as an initializer_list.

Most new compilers have the new dangerous behavior now. There's a "canary" in the unit test which is meant to point out whether your compiler has the bad behavior: https://github.com/dropbox/json11/blob/master/test.cpp#L195

There is a new issue being tracked by the standards committee on this, but I haven't seen any action. Latest status is here: http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2137

Meanwhile the best workaround is to build these nested arrays in multiple steps using push_back()

Uses CXX_STANDARD to specify a C++11 build, which avoids issues when a build contains C files.

Fixes #70

The tests seem to fail on my laptop, with or without this change (same output)

build ▹ ./json11_test
k1: v1
k3: ["a", 123, true, false, null]
    - "a"
    - 123
    - true
    - false
    - null
Result: {"a": 1, "b": "text", "c": [1, 2, 3]}
Result: {}
Failed: malformed comment
Failed: unexpected end of input inside inline comment
Failed: unexpected end of input inside comment
Failed: unexpected end of input inside multi-line comment
obj: {"k1": "v1", "k2": 42, "k3": ["a", 123, true, false, null]}
Assertion failed: (nested_array.array_items().size() == 1), function json11_test, file /Users/adam/workspace/json11/test.cpp, line 198.
Abort trap: 6

I need to serialize value (long timestamp in 10^7 Hz timer) exactly as int, so I added support for uint64_t integers on 64-bit platforms via intmax_t type.

On 32-bit platforms (no under my hand to test) everything should work well.

Here is the sample response of one of my apis. And I would like to parse it using json11.

{
  "status": 1,
  "message": {
    "fundNames": [
      "SBI Premier Liquid Fund - Institutional - Growth",
      "SBI Premier Liquid Fund - Institutional - Growth"
    ],
    "fundNavs": [
      [
        {
          "date": "2017-02-22",
          "nav": 2552.4454
        },
        {
          "date": "2017-02-21",
          "nav": 2551.9707
        }
      ],
      [
        {
          "date": "2017-02-22",
          "nav": 2552.4454
        },
        {
          "date": "2017-02-21",
          "nav": 2551.9707
        },
        {
          "date": "2017-02-18",
          "nav": 2550.6512
        }
      ]
    ]
  }
}

Here is my try

        string inputError;
        auto y = Json::parse(r.text, inputError);
        auto status = y["status"].int_value();
        if (status == 1) {
            for (auto &k: y["message"].array_items()) {
                map<string, double> data;
                for (auto &m : k[fundNavs].array_items()) {
                    auto nav = m["nav"].number_value();
                    auto nDate = m["date"].string_value();
                    data[nDate] = nav;
                }
            }
        }

Story

When comparing two nodes we can speed up use cases where we reuse node instances partially or totally:

Json my_json = Json::object {
    { "key1", "value1" },
    { "key2", false },
    { "key3", Json::array { 1, 2, 3 } },
};
auto my_other_json = my_json;
if (my_json == my_other_json)
{
    ...
}

Two nodes sharing a portion of nodes:

Json common = Json::object {
    { "key1", "value1" },
    { "key2", false },
    { "key3", Json::array { 1, 2, 3 } },
};
Json a = Son::object {
    { "common", common },
    { "extra value", "value1" }
}
Json b = Son::object {
    { "common", common },
    { "extra value", "value1" }
}
if (a == b) {
    ...
}

It may be useful to apply the same concept also for operator<, in such case would always return false:

bool Json::operator< (const Json &other) const {
    if (m_ptr == other.m_ptr)
        return false;
    if (m_ptr->type() != other.m_ptr->type())
        return m_ptr->type() < other.m_ptr->type();
    return m_ptr->less(other.m_ptr.get());
}

These little changes would open memory + CPU optimisations of this sort:

Json reuse_instances(Json new_node)
{
   static std::set<Json> known_values;

   auto it = used_values.find(new_node);
   if (it != used_values.end()) {
       return it->second;
   }

   // may recursively do this for member nodes of object and arrays
   ...

   known_values.insert(new_node);
   return node;
}

...

Json my_object = reuse_instances(Json(Json::object {
    { "key1", "value1" },
    { "key2", false },
    { "key3", Json::array { 1, 2, 3 } },
}));

I'm using a different string class than std::string. It would be good to add this either as a #define or a template parameter which defaults to std::string.

If so, is this something which you would accept into the code base?

Then, which method would you prefer?

If it would be a define, it should be something like: #ifndef JSON11_STRING_TYPE #define JSON11_STRING_TYPE std::string #endif

I have a domain-specific vector class as well, which might be useful to tweak as well...

This PR adds a cmake option for the DR 1467 tests, as described in PR #71

That said, the test output seems to be the same regardless. This is the output after applying this PR, with an extra debug line printed in the relevant canary section of the tests

[email protected]:~/workspace/json11/build$ cmake ..
-- The CXX compiler identification is GNU 5.4.0
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/adam/workspace/json11/build
[email protected]:~/workspace/json11/build$ make
Scanning dependencies of target json11
[ 25%] Building CXX object CMakeFiles/json11.dir/json11.cpp.o
[ 50%] Linking CXX static library libjson11.a
[ 50%] Built target json11
Scanning dependencies of target json11_test
[ 75%] Building CXX object CMakeFiles/json11_test.dir/test.cpp.o
[100%] Linking CXX executable json11_test
[100%] Built target json11_test
[email protected]:~/workspace/json11/build$ ./json11_test
k1: v1
k3: ["a", 123, true, false, null]
    - "a"
    - 123
    - true
    - false
    - null
Result: {"a": 1, "b": "text", "c": [1, 2, 3]}
Result: {}
Failed: malformed comment
Failed: unexpected end of input inside inline comment
Failed: unexpected end of input inside comment
Failed: unexpected end of input inside multi-line comment
obj: {"k1": "v1", "k2": 42, "k3": ["a", 123, true, false, null]}
-- performing canary test for DR1467
{"key1": "value1", "key2": false, "key3": [1, 2, 3]}
[[1, 2], [10, 20], [100, 200]]
[email protected]:~/workspace/json11/build$ cmake -D JSON11_ENABLE_DR1467_CANARY=off ..
-- Configuring done
-- Generating done
-- Build files have been written to: /home/adam/workspace/json11/build
[email protected]:~/workspace/json11/build$ make
[ 25%] Building CXX object CMakeFiles/json11.dir/json11.cpp.o
[ 50%] Linking CXX static library libjson11.a
[ 50%] Built target json11
[ 75%] Building CXX object CMakeFiles/json11_test.dir/test.cpp.o
[100%] Linking CXX executable json11_test
[100%] Built target json11_test
[email protected]:~/workspace/json11/build$ ./json11_test
k1: v1
k3: ["a", 123, true, false, null]
    - "a"
    - 123
    - true
    - false
    - null
Result: {"a": 1, "b": "text", "c": [1, 2, 3]}
Result: {}
Failed: malformed comment
Failed: unexpected end of input inside inline comment
Failed: unexpected end of input inside comment
Failed: unexpected end of input inside multi-line comment
obj: {"k1": "v1", "k2": 42, "k3": ["a", 123, true, false, null]}
-- NOT performing canary test for DR1467
{"key1": "value1", "key2": false, "key3": [1, 2, 3]}
[[1, 2], [10, 20], [100, 200]]

MSVC build was failing under Visual Studio 2017 with CMake v3.15.5 and v3.16.2 generated project files.

Compiler cl.exe was failing with following error code for all GCC specific compiler flags

cl : Command line error D8021: invalid numeric argument '/Wextra'

CHECK_CXX_COMPILER_FLAG() evaluates with GCC specific compiler flags to positive result.

Please review and merge this pull request : https://github.com/random-basad/json11/commit/7a03087db4898e50d41d06e1fd7945c92a109bd4

Thanks. @artwyman

/home/genstor/toolchain/json11-master/json/json11.hpp:228:25: error: 'virtual const json11::Json& json11::JsonValue::operator[](const string&) const' was hidden [-Werror=overloaded-virtual]
     virtual const Json &operator[](const std::string &key) const;
                         ^
/home/genstor/toolchain/json11-master/json/json11.cpp:206:18: error:   by 'virtual const json11::Json& json11::JsonArray::operator[](size_t) const' [-Werror=overloaded-virtual]
     const Json & operator[](size_t i) const override;
                  ^
In file included from /home/genstor/toolchain/json11-master/json/json11.cpp:22:0:
/home/genstor/toolchain/json11-master/json/json11.hpp:226:25: error: 'virtual const json11::Json& json11::JsonValue::operator[](size_t) const' was hidden [-Werror=overloaded-virtual]
     virtual const Json &operator[](size_t i) const;
                         ^
/home/genstor/toolchain/json11-master/json/json11.cpp:214:18: error:   by 'virtual const json11::Json& json11::JsonObject::operator[](const string&) const' [-Werror=overloaded-virtual]
     const Json & operator[](const string &key) const override;
                  ^

With set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -fno-omit-frame-pointer -fsanitize=address,undefined") set (CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fno-omit-frame-pointer -fsanitize=address,undefined")

I get the following report:

0x603000115b40: note: object has invalid vptr
 18 00 00 66  00 f1 21 58 55 55 00 00  01 00 00 00 01 00 00 00  b8 f2 21 58 55 55 00 00  be be be be
              ^~~~~~~~~~~~~~~~~~~~~~~
              invalid vptr
/usr/include/c++/8/bits/shared_ptr_base.h:728:4: runtime error: member call on address 0x603000115b40 which does not point to an object of type '_Sp_counted_base'
0x603000115b40: note: object has invalid vptr
 18 00 00 66  00 f1 21 58 55 55 00 00  02 00 00 00 01 00 00 00  b8 f2 21 58 55 55 00 00  be be be be
              ^~~~~~~~~~~~~~~~~~~~~~~
              invalid vptr

This is with git cloned a few moments ago. I can dig deeper a bit later. Have you tested json11 with asan?

I added the following to json11.hpp

 /// @weepy additions
        operator long() {
            return (long) int_value();
        }
        
        operator int() {
            return int_value();
        }
        operator float() {
            return (float) number_value();
        }
        operator double() {
            return (double) number_value();
        }
        operator std::string() {
            return string_value();
        }
        operator bool() {
            return bool_value();
        }
        
        operator object() {
            return object_items();
        }
        
        operator array() {
            return array_items();
        }

It makes using json11 much more convenient as the compiler will auto cast your variables for you, eg:
int id = myJson["id"];