README.md 10.6 KB
Newer Older
I
Iñaki Baz Castillo 已提交
1
# JsonCpp
2

3 4
[![badge](https://img.shields.io/badge/conan.io-jsoncpp%2F1.8.0-green.svg?logo=data:image/png;base64%2CiVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAA1VBMVEUAAABhlctjlstkl8tlmMtlmMxlmcxmmcxnmsxpnMxpnM1qnc1sn85voM91oM11oc1xotB2oc56pNF6pNJ2ptJ8ptJ8ptN9ptN8p9N5qNJ9p9N9p9R8qtOBqdSAqtOAqtR%2BrNSCrNJ/rdWDrNWCsNWCsNaJs9eLs9iRvNuVvdyVv9yXwd2Zwt6axN6dxt%2Bfx%2BChyeGiyuGjyuCjyuGly%2BGlzOKmzOGozuKoz%2BKqz%2BOq0OOv1OWw1OWw1eWx1eWy1uay1%2Baz1%2Baz1%2Bez2Oe02Oe12ee22ujUGwH3AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgBQkREyOxFIh/AAAAiklEQVQI12NgAAMbOwY4sLZ2NtQ1coVKWNvoc/Eq8XDr2wB5Ig62ekza9vaOqpK2TpoMzOxaFtwqZua2Bm4makIM7OzMAjoaCqYuxooSUqJALjs7o4yVpbowvzSUy87KqSwmxQfnsrPISyFzWeWAXCkpMaBVIC4bmCsOdgiUKwh3JojLgAQ4ZCE0AMm2D29tZwe6AAAAAElFTkSuQmCC)](http://www.conan.io/source/jsoncpp/1.8.0/theirix/ci)

5 6 7
[JSON][json-org] is a lightweight data-interchange format. It can represent
numbers, strings, ordered sequences of values, and collections of name/value
pairs.
8

9
[json-org]: http://json.org/
10

I
Iñaki Baz Castillo 已提交
11
JsonCpp is a C++ library that allows manipulating JSON values, including
12 13 14
serialization and deserialization to and from strings. It can also preserve
existing comment in unserialization/serialization steps, making it a convenient
format to store user input files.
15

I
Iñaki Baz Castillo 已提交
16 17 18 19 20 21 22 23

## Documentation

[JsonCpp documentation][JsonCpp-documentation] is generated using [Doxygen][].

[JsonCpp-documentation]: http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html
[Doxygen]: http://www.doxygen.org

C
Christopher Dunn 已提交
24

C
Christopher Dunn 已提交
25
## A note on backward-compatibility
I
Iñaki Baz Castillo 已提交
26

C
Christopher Dunn 已提交
27
* `1.y.z` is built with C++11.
28
* `0.y.z` can be used with older compilers.
C
Christopher Dunn 已提交
29
* Major versions maintain binary-compatibility.
30

I
Iñaki Baz Castillo 已提交
31 32 33

## Using JsonCpp in your project

34
The recommended approach to integrating JsonCpp in your project is to include
35 36
the [amalgamated source](#generating-amalgamated-source-and-header) (a single
`.cpp` file and two `.h` files) in your project, and compile and build as you
37
would any other source file. This ensures consistency of compilation flags and
38
ABI compatibility, issues which arise when building shared or static
39
libraries. See the next section for instructions.
40

I
Iñaki Baz Castillo 已提交
41
The `include/` should be added to your compiler include path. JsonCpp headers
42 43 44 45
should be included as follow:

    #include <json/json.h>

I
Iñaki Baz Castillo 已提交
46 47 48
If JsonCpp was built as a dynamic library on Windows, then your project needs to define the macro `JSON_DLL`.

### Generating amalgamated source and header
49

50 51 52 53 54 55 56 57 58 59
JsonCpp is provided with a script to generate a single header and a single
source file to ease inclusion into an existing project. The amalgamated source
can be generated at any time by running the following command from the
top-directory (this requires Python 2.6):

    python amalgamate.py

It is possible to specify header name. See the `-h` option for detail.

By default, the following files are generated:
I
Iñaki Baz Castillo 已提交
60

61 62 63 64 65 66 67 68
* `dist/jsoncpp.cpp`: source file that needs to be added to your project.
* `dist/json/json.h`: corresponding header file for use in your project. It is
  equivalent to including `json/json.h` in non-amalgamated source. This header
  only depends on standard headers.
* `dist/json/json-forwards.h`: header that provides forward declaration of all
  JsonCpp types.

The amalgamated sources are generated by concatenating JsonCpp source in the
I
Iñaki Baz Castillo 已提交
69
correct order and defining the macro `JSON_IS_AMALGAMATION` to prevent inclusion of other headers.
70 71


I
Iñaki Baz Castillo 已提交
72 73
## Contributing to JsonCpp

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
### Building and testing with Conan

[Conan](https://www.conan.io/#/) is an open source package manager intended for C/C++ projects.
It is cross platform and build system agnostic.

Conan requires Python for running, and can be installed using pip:

    pip install conan

 Detailed instructions can be found on [conan docs](http://docs.conan.io/en/latest/).

For build jsoncpp with conan, you need to create a [conanfile.txt](http://docs.conan.io/en/latest/reference/conanfile_txt.html) or a [conanfile.py](http://docs.conan.io/en/latest/reference/conanfile.html). The first is simpler, but the second is more flexible.

This is a sample conanfile.txt:

```
[requires]
jsoncpp/1.8.0@theirix/ci

[generators]
cmake
```

**Note**: cmake is not required, you can use other [integrations](http://docs.conan.io/en/latest/integrations.html). Or you can set the appropriate environment variables, using [virtualenv generators](http://docs.conan.io/en/latest/mastering/virtualenv.html).

Then run the following command from the conanfile directory:

    conan install --build missing

This will try to download the appropriate package for your settings (OS, compiler, architecture) from the [recipe packages](https://www.conan.io/source/jsoncpp/1.8.0/theirix/ci). If it is not found, the package will be built.

**Note**: you do not need to install cmake to build jsoncpp using conan, because the recipe will download it automatically.

If you need, you can customize the jsoncpp recipe. Just clone/fork [it from github](https://github.com/theirix/conan-jsoncpp/).

See [integrations instructions](http://docs.conan.io/en/latest/integrations.html) for how to use your build system with conan.

I
Iñaki Baz Castillo 已提交
111 112 113
### Building and testing with CMake

[CMake][] is a C++ Makefiles/Solution generator. It is usually available on most Linux system as package. On Ubuntu:
114 115 116 117 118 119

    sudo apt-get install cmake

[CMake]: http://www.cmake.org

Note that Python is also required to run the JSON reader/writer tests. If
120
missing, the build will skip running those tests.
121

122
When running CMake, a few parameters are required:
123

I
Iñaki Baz Castillo 已提交
124
* A build directory where the makefiles/solution are generated. It is also used
125
  to store objects, libraries and executables files.
I
Iñaki Baz Castillo 已提交
126
* The generator to use: makefiles or Visual Studio solution? What version or
127
  Visual Studio, 32 or 64 bits solution?
128 129 130 131 132 133

Steps for generating solution/makefiles using `cmake-gui`:

* Make "source code" point to the source directory.
* Make "where to build the binary" point to the directory to use for the build.
* Click on the "Grouped" check box.
134
* Review JsonCpp build options (tick `BUILD_SHARED_LIBS` to build as a
135 136 137 138
  dynamic library).
* Click the configure button at the bottom, then the generate button.
* The generated solution/makefiles can be found in the binary directory.

139
Alternatively, from the command-line on Unix in the source directory:
140

141 142
    mkdir -p build/debug
    cd build/debug
B
Brandon Myers 已提交
143
    cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_STATIC_LIBS=ON -DBUILD_SHARED_LIBS=OFF -DARCHIVE_INSTALL_DIR=. -G "Unix Makefiles" ../..
144 145
    make

C
Christopher Dunn 已提交
146 147 148 149
For a good pkg-config file, add:

    -DCMAKE_INSTALL_INCLUDEDIR=include/jsoncpp

150
Running `cmake -h` will display the list of available generators (passed using
151 152 153 154 155
the `-G` option).

By default CMake hides compilation commands. This can be modified by specifying
`-DCMAKE_VERBOSE_MAKEFILE=true` when generating makefiles.

I
Iñaki Baz Castillo 已提交
156 157 158 159
### Building and testing with SCons

**Note:** The SCons-based build system is deprecated. Please use CMake (see the
section above).
160

161
JsonCpp can use [Scons][] as a build system. Note that SCons requires Python to
162 163 164 165 166 167
be installed.

[SCons]: http://www.scons.org/

Invoke SCons as follows:

168
    scons platform=$PLATFORM [TARGET]
169

170
where `$PLATFORM` may be one of:
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185

* `suncc`: Sun C++ (Solaris)
* `vacpp`: Visual Age C++ (AIX)
* `mingw`
* `msvc6`: Microsoft Visual Studio 6 service pack 5-6
* `msvc70`: Microsoft Visual Studio 2002
* `msvc71`: Microsoft Visual Studio 2003
* `msvc80`: Microsoft Visual Studio 2005
* `msvc90`: Microsoft Visual Studio 2008
* `linux-gcc`: Gnu C++ (linux, also reported to work for Mac OS X)

If you are building with Microsoft Visual Studio 2008, you need to set up the
environment by running `vcvars32.bat` (e.g. MSVC 2008 command prompt) before
running SCons.

I
Iñaki Baz Castillo 已提交
186 187
### Running the tests manually

188 189 190 191 192 193 194 195
You need to run tests manually only if you are troubleshooting an issue.

In the instructions below, replace `path/to/jsontest` with the path of the
`jsontest` executable that was compiled on your platform.

    cd test
    # This will run the Reader/Writer tests
    python runjsontests.py path/to/jsontest
196

197 198 199 200 201 202
    # This will run the Reader/Writer tests, using JSONChecker test suite
    # (http://www.json.org/JSON_checker/).
    # Notes: not all tests pass: JsonCpp is too lenient (for example,
    # it allows an integer to start with '0'). The goal is to improve
    # strict mode parsing to get all tests to pass.
    python runjsontests.py --with-json-checker path/to/jsontest
203

204 205
    # This will run the unit tests (mostly Value)
    python rununittests.py path/to/test_lib_json
206

207 208
    # You can run the tests using valgrind:
    python rununittests.py --valgrind path/to/test_lib_json
209

I
Iñaki Baz Castillo 已提交
210 211
### Running the tests using SCons

C
Christopher Dunn 已提交
212 213 214
Note that tests can be run using SCons using the `check` target:

    scons platform=$PLATFORM check
215

I
Iñaki Baz Castillo 已提交
216 217
### Building the documentation

218
Run the Python script `doxybuild.py` from the top directory:
219

C
Christopher Dunn 已提交
220
    python doxybuild.py --doxygen=$(which doxygen) --open --with-dot
221

222
See `doxybuild.py --help` for options.
223

I
Iñaki Baz Castillo 已提交
224 225
### Adding a reader/writer test

226
To add a test, you need to create two files in test/data:
227 228 229 230 231 232 233

* a `TESTNAME.json` file, that contains the input document in JSON format.
* a `TESTNAME.expected` file, that contains a flatened representation of the
  input document.

The `TESTNAME.expected` file format is as follows:

I
Iñaki Baz Castillo 已提交
234
* Each line represents a JSON element of the element tree represented by the
235
  input document.
I
Iñaki Baz Castillo 已提交
236
* Each line has two parts: the path to access the element separated from the
237 238
  element value by `=`. Array and object values are always empty (i.e.
  represented by either `[]` or `{}`).
I
Iñaki Baz Castillo 已提交
239
* Element path `.` represents the root element, and is used to separate object
240 241
  members. `[N]` is used to specify the value of an array element at index `N`.

I
Iñaki Baz Castillo 已提交
242
See the examples `test_complex_01.json` and `test_complex_01.expected` to better understand element paths.
243

I
Iñaki Baz Castillo 已提交
244 245 246
### Understanding reader/writer test output

When a test is run, output files are generated beside the input test files. Below is a short description of the content of each file:
247

248 249 250 251 252 253 254 255 256 257 258 259
* `test_complex_01.json`: input JSON document.
* `test_complex_01.expected`: flattened JSON element tree used to check if
  parsing was corrected.
* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest`
  from reading `test_complex_01.json`.
* `test_complex_01.rewrite`: JSON document written by `jsontest` using the
  `Json::Value` parsed from `test_complex_01.json` and serialized using
  `Json::StyledWritter`.
* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by
  `jsontest` from reading `test_complex_01.rewrite`.
* `test_complex_01.process-output`: `jsontest` output, typically useful for
  understanding parsing errors.
260

I
Iñaki Baz Castillo 已提交
261 262
## License

263
See the `LICENSE` file for details. In summary, JsonCpp is licensed under the
264
MIT license, or public domain if desired and recognized in your jurisdiction.