json c
1.0.0
página principal
vcpkgJSON-C implementa un modelo de objetos de recuento de referencias que le permite construir fácilmente objetos JSON en C, generarlos como cadenas con formato JSON y analizar cadenas con formato JSON nuevamente en la representación C de objetos JSON. Su objetivo es cumplir con RFC 8259.
Vaya a Uso de json-c o consulte los documentos de la API, si ya tiene json-c instalado y listo para usar.
Página de inicio de json-c: https://github.com/json-c/json-c/wiki
Si tiene preguntas sobre el uso de json-c, inicie un hilo en nuestros foros en: https://groups.google.com/forum/#!forum/json-c
Si cree que ha descubierto un error, infórmelo en (https://github.com/json-c/json-c/issues). Asegúrese de incluir la versión de json-c que está utilizando, el sistema operativo que está ejecutando y cualquier otro detalle relevante. Se agradecen mucho los casos de prueba y/o parches totalmente reproducibles para solucionar problemas.
Las correcciones de errores o pequeñas funciones nuevas se pueden enviar directamente como una solicitud de extracción. Para nuevas funciones importantes o cambios importantes de cualquier tipo, primero inicie una discusión en los foros.
git , gcc y cmake Si ya tiene json-c instalado, consulte Vincular a libjson-c para saber cómo compilar y vincular su programa con él.
Estado de construcción
Estado de la prueba
gcc , clang u otro compilador de C
cmake>=2.8 , >=3.16 recomendado, cmake=>3.1 para pruebas
Para generar documentos también necesitarás:
doxygen>=1.8.13Si tiene un sistema relativamente moderno, probablemente podrá instalar los requisitos previos utilizando el sistema de empaquetado de su sistema operativo.
sudo apt install git
sudo apt install cmake
sudo apt install doxygen # optional
sudo apt install valgrind # optional json-c repositorio de GitHub: https://github.com/json-c/json-c
$ git clone https://github.com/json-c/json-c.git
$ mkdir json-c-build
$ cd json-c-build
$ cmake ../json-c # See CMake section below for custom arguments Nota: también es posible colocar su directorio de compilación dentro del directorio fuente json-c, o incluso no usar un directorio de compilación separado, pero es posible que ciertas cosas no funcionen del todo bien (en particular, make distcheck ).
Entonces:
$ make
$ make test
$ make USE_VALGRIND=0 test # optionally skip using valgrind
$ sudo make install # it could be necessary to execute make installLa documentación de la biblioteca se puede generar directamente desde el código fuente utilizando la herramienta Doxygen:
# in build directory
make doc
google-chrome doc/html/index.htmlLa biblioteca json-c está construida con CMake, que puede aceptar algunas opciones.
| Variable | Tipo | Descripción |
|---|---|---|
| CMAKE_INSTALL_PREFIX | Cadena | La ubicación de instalación. |
| CMAKE_BUILD_TYPE | Cadena | El valor predeterminado es "depurar". |
| BUILD_SHARED_LIBS | booleano | La compilación predeterminada genera una biblioteca dinámica (dll/so). Configúrelo en APAGADO para crear solo una biblioteca estática. |
| BUILD_STATIC_LIBS | booleano | La compilación predeterminada genera una biblioteca estática (lib/a). Configúrelo en APAGADO para crear solo una biblioteca compartida. |
| DISABLE_STATIC_FPIC | booleano | El valor predeterminado crea código independiente de la posición. Configúrelo en APAGADO para crear solo una biblioteca compartida. |
| DISABLE_BSYMBÓLIC | booleano | Deshabilite el uso de funciones -Bsimbólicas. |
| DISABLE_THREAD_LOCAL_STORAGE | booleano | Deshabilite el uso del almacenamiento local de subprocesos (HAVE___THREAD). |
| DISABLE_WERROR | booleano | Deshabilite el uso de -Werror. |
| DISABLE_EXTRA_LIBS | booleano | Deshabilitar el uso de bibliotecas adicionales, libbsd |
| DISABLE_JSON_POINTER | booleano | Omita la compatibilidad con json_pointer de la compilación. |
| ENABLE_RDRAND | booleano | Habilite la semilla de hash RNG de hardware RDRAND. |
| ENABLE_THREADING | booleano | Habilite el soporte de subprocesos parciales. |
| OVERRIDE_GET_RANDOM_SEED | Cadena | Un bloque de código para usar en lugar de la implementación predeterminada de json_c_get_random_seed(), por ejemplo, en plataformas integradas donde ni siquiera funciona el recurso alternativo time(). Debe ser una sola línea. |
Pase estas opciones como -D en la línea de comandos de CMake.
# build a static library only
cmake -DBUILD_SHARED_LIBS=OFF ..Aunque json-c no admite el acceso totalmente multiproceso a árboles de objetos, tiene algo de código para ayudar a que su uso en programas con subprocesos sea un poco más seguro. Actualmente, esto se limita al uso de operaciones atómicas para json_object_get() y json_object_put().
Dado que esto puede tener un impacto en el rendimiento, al menos 3 veces más lento según https://stackoverflow.com/a/11609063, está deshabilitado de forma predeterminada. Puede activarlo ajustando su comando cmake con: -DENABLE_THREADING=ON
Por otra parte, la función hash predeterminada utilizada para las claves de campo de objetos, lh_char_hash, utiliza una operación de comparación e intercambio para garantizar que la semilla aleatoria solo se genere una vez. Como se trata de una operación única, siempre se compila cuando la operación de comparación e intercambio está disponible.
Para aquellos familiarizados con el antiguo método autoconf/autogen.sh/configure, existe un script contenedor cmake-configure para facilitar la transición a cmake.
mkdir build
cd build
../cmake-configure --prefix=/some/install/path
makecmake-configure puede tomar algunas opciones.
| opciones | Descripción |
|---|---|
| prefijo = PREFIJO | instalar archivos independientes de la arquitectura en PREFIX |
| habilitar subprocesos | Habilite el código para admitir el uso parcialmente de subprocesos múltiples |
| habilitar-rdrand | Habilite la generación de RNG Hash Seed de hardware RDRAND en plataformas x86/x64 compatibles. |
| habilitar-compartido | construir bibliotecas compartidas [predeterminado = sí] |
| habilitar-estático | construir bibliotecas estáticas [predeterminado = sí] |
| desactivar-Bsimbólico | Evite vincular con -Bsymbolic-function |
| error-deshabilitar | Evite tratar las advertencias del compilador como errores fatales |
De forma predeterminada, si valgrind está disponible, la ejecución de pruebas lo utiliza. Eso puede ralentizar considerablemente las pruebas, así que para desactivarlo utiliza:
export USE_VALGRIND=0Para ejecutar pruebas se recomienda un directorio de compilación independiente:
mkdir build-test
cd build-test
# VALGRIND=1 causes -DVALGRIND=1 to be passed when compiling code
# which uses slightly slower, but valgrind-safe code.
VALGRIND=1 cmake ..
make
make test
# By default, if valgrind is available running tests uses it.
make USE_VALGRIND=0 test # optionally skip using valgrind Si una prueba falla, verifique Testing/Temporary/LastTest.log , tests/testSubDir/${testname}/${testname}.vg.out y otros archivos similares. Si no hay suficiente salida, intente:
VERBOSE=1 CTEST_OUTPUT_ON_FAILURE=1 make testo
JSONC_TEST_TRACE=1 make testy verifique los archivos de registro nuevamente.
vcpkgPuede descargar e instalar JSON-C utilizando el administrador de dependencias vcpkg:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install json-c
Los miembros del equipo de Microsoft y los contribuyentes de la comunidad mantienen actualizado el puerto JSON-C en vcpkg. Si la versión no está actualizada, cree un problema o una solicitud de extracción en el repositorio de vcpkg.
La compilación en Android ahora tiene un soporte particularmente bueno, pero ha habido algunos informes de éxito utilizando https://developer.android.com/ndk/guides/cmake
mkdir json-c-build
cd json-c-build/
export NDK_HOME=~/Library/Android/sdk/ndk/22.1.7171670/
cmake
--toolchain=$NDK_HOME/build/cmake/android.toolchain.cmake
-DANDROID_STL=none
-DANDROID_ABI=arm64-v8a
-DANDROID_PLATFORM=android-29
-DANDROID_LD=lld
-DCMAKE_BUILD_TYPE=MinSizeRel
-DCMAKE_INSTALL_PREFIX=<install prefix>
-DENABLE_THREADING=true
..
make install
libjson-c Si su sistema tiene pkgconfig , puede agregar esto a su makefile :
CFLAGS += $( shell pkg-config --cflags json-c)
LDFLAGS += $( shell pkg-config --libs json-c) Sin pkgconfig , podrías hacer algo como esto:
JSON_C_DIR =/path/to/json_c/install
CFLAGS += -I $( JSON_C_DIR ) /include/json-c
# Or to use lines like: #include <json-c/json_object.h>
# CFLAGS += -I$(JSON_C_DIR)/include
LDFLAGS+ = -L $( JSON_C_DIR ) /lib -ljson-cSi su proyecto usa cmake:
find_package (json-c CONFIG)
target_link_libraries ( ${PROJECT_NAME} PRIVATE json-c::json-c) cd build
cmake -DCMAKE_PREFIX_PATH=/path/to/json_c/install/lib64/cmake ..Para usar json-c, puede incluir json.h o, preferiblemente, uno de los siguientes archivos de encabezado más específicos:
json_object_object_foreach() en json_object.h)Para obtener una lista completa de encabezados, consulte files.html
El tipo principal en json-c es json_object. Describe un árbol contado de referencia de objetos json que se crean analizando texto con un json_tokener (es decir, json_tokener_parse_ex() ), o creando (con json_object_new_object() , json_object_new_int() , etc...) y agregando (con json_object_object_add() , json_object_array_add() , etc...) individualmente. Normalmente, cada objeto del árbol tendrá una referencia de su padre. Cuando haya terminado con el árbol de objetos, llame a json_object_put() solo en el objeto raíz para liberarlo, lo que se repetirá a través de cualquier objeto secundario que llame a json_object_put() en cada uno de ellos por turno.
Puede obtener una referencia a un solo hijo ( json_object_object_get() o json_object_array_get_idx() ) y usar ese objeto siempre que su padre sea válido.
Si necesita que un objeto secundario viva más que su padre, puede incrementar el recuento del niño ( json_object_get() ) para permitirle sobrevivir a la liberación del padre o a su eliminación de su padre ( json_object_object_del() o json_object_array_del_idx() ).
Al analizar texto, el objeto json_tokener es independiente del json_object que devuelve. Se puede asignar ( json_tokener_new() ) usar una o varias veces ( json_tokener_parse_ex() y liberar ( json_tokener_free() ) mientras los objetos json_object siguen vivos.
Un árbol json_object se puede volver a serializar en una cadena con json_object_to_json_string_ext() . La cadena que se devuelve solo es válida hasta la siguiente llamada "to_json_string" en ese mismo objeto. Además, se libera cuando se libera json_object.
