README.md 7.7 KB
Newer Older
1 2
Introduction
------------
3

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

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

10 11 12 13
JsonCpp is a C++ library that allows manipulating JSON values, including
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.
14

15

16 17
Using JsonCpp in your project
-----------------------------
18

19 20 21 22
The recommended approach to integrating JsonCpp in your project is to build the
the amalgamated source (a single `.cpp` file) with your own build system. This
ensures consistency of compilation flags and ABI compatibility. See the section
"Generating amalgamated source and header" for instructions.
23
  
24 25 26 27 28 29 30
The `include/` should be added to your compiler include path. Jsoncpp headers
should be included as follow:

    #include <json/json.h>

If JsonCpp was build as a dynamic library on Windows, then your project needs to
define the macro `JSON_DLL`.
31 32


33 34 35 36 37 38 39 40 41 42 43
Building and testing with new CMake
-----------------------------------

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

    sudo apt-get install cmake

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

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

46
When running CMake, a few parameters are required:
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

* a build directory where the makefiles/solution are generated. It is also used
  to store objects, libraries and executables files.
* the generator to use: makefiles or Visual Studio solution? What version or
  Visual Studio, 32 or 64 bits solution? 

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.
* Review JsonCpp build options (tick `JSONCPP_LIB_BUILD_SHARED` to build as a
  dynamic library).
* Click the configure button at the bottom, then the generate button.
* The generated solution/makefiles can be found in the binary directory.

63
Alternatively, from the command-line on Unix in the source directory:
64 65 66 67 68 69 70 71 72 73 74 75

    mkdir -p ../build/debug
    cd ../build/debug
    cmake -DCMAKE_BUILD_TYPE=debug -DJSONCPP_LIB_BUILD_SHARED=OFF -G "Unix Makefiles" ../../jsoncpp-src
    make

Running `cmake -`" will display the list of available generators (passed using
the `-G` option).

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

76

77 78 79 80 81 82
Building and testing with SCons
-------------------------------

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

83
JsonCpp can use [Scons][] as a build system. Note that SCons requires Python to
84 85 86 87 88 89
be installed.

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

Invoke SCons as follows:

90
    scons platform=$PLATFORM [TARGET]
91

92
where `$PLATFORM` may be one of:
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108

* `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.


109 110
Running the tests manually
--------------------------
111

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
Note that test can be run using SCons using the `check` target:

    scons platform=$PLATFORM check

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
    
    # 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
    
    # This will run the unit tests (mostly Value)
    python rununittests.py path/to/test_lib_json
    
    # You can run the tests using valgrind:
    python rununittests.py --valgrind path/to/test_lib_json
137 138


139 140
Building the documentation
--------------------------
141

142
Run the Python script `doxybuild.py` from the top directory:
143

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

146
See `doxybuild.py --help` for options.
147

148

149 150
Generating amalgamated source and header
----------------------------------------
151 152

JsonCpp is provided with a script to generate a single header and a single
153 154 155
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):
156

157
    python amalgamate.py
158

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

161 162 163 164 165 166 167
By default, the following files are generated:
* `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.
168

169
The amalgamated sources are generated by concatenating JsonCpp source in the
170
correct order and defining the macro `JSON_IS_AMALGAMATION` to prevent inclusion
171
of other headers.
172

173

174 175
Adding a reader/writer test
---------------------------
176 177

To add a test, you need to create two files in test/data:
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194

* 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:

* each line represents a JSON element of the element tree represented by the
  input document.
* each line has two parts: the path to access the element separated from the
  element value by `=`. Array and object values are always empty (i.e.
  represented by either `[]` or `{}`).
* element path: `.` represents the root element, and is used to separate object
  members. `[N]` is used to specify the value of an array element at index `N`.

See the examples `test_complex_01.json` and `test_complex_01.expected` to better
understand element paths.
195 196


197 198
Understanding reader/writer test output
---------------------------------------
199

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

203 204 205 206 207 208 209 210 211 212 213 214
* `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.
215

216

217 218
License
-------
219 220

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