json c
1.0.0
página principal
vcpkgJSON-C implementa um modelo de objeto de contagem de referência que permite construir facilmente objetos JSON em C, produzi-los como strings formatadas em JSON e analisar strings formatadas em JSON de volta na representação C de objetos JSON. Seu objetivo é estar em conformidade com a RFC 8259.
Vá para Usando json-c ou verifique a documentação da API, se você já tiver o json-c instalado e pronto para uso.
Página inicial do json-c: https://github.com/json-c/json-c/wiki
Se você tiver dúvidas sobre o uso do json-c, inicie um tópico em nossos fóruns em: https://groups.google.com/forum/#!forum/json-c
Se você acredita que descobriu um bug, relate-o em (https://github.com/json-c/json-c/issues). Certifique-se de incluir a versão do json-c que você está usando, o sistema operacional em que está executando e quaisquer outros detalhes relevantes. Casos de teste e/ou patches totalmente reproduzíveis para corrigir problemas são muito apreciados.
Correções de bugs ou pequenos novos recursos podem ser enviados diretamente como uma solicitação pull. Para novos recursos importantes ou grandes mudanças de qualquer tipo, primeiro inicie uma discussão nos fóruns.
git , gcc e cmake Se você já tem o json-c instalado, consulte Vinculando ao libjson-c para saber como construir e vincular seu programa a ele.
Status de construção
Status do teste
gcc , clang ou outro compilador C
cmake>=2.8 , >=3.16 recomendado, cmake=>3.1 para testes
Para gerar documentos você também precisará de:
doxygen>=1.8.13Se você estiver em um sistema relativamente moderno, provavelmente conseguirá instalar os pré-requisitos usando o sistema de empacotamento do seu sistema operacional.
sudo apt install git
sudo apt install cmake
sudo apt install doxygen # optional
sudo apt install valgrind # optional repositório json-c 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: também é possível colocar seu diretório de compilação dentro do diretório de origem json-c ou até mesmo não usar um diretório de compilação separado, mas certas coisas podem não funcionar corretamente (principalmente make distcheck )
Então:
$ make
$ make test
$ make USE_VALGRIND=0 test # optionally skip using valgrind
$ sudo make install # it could be necessary to execute make installA documentação da biblioteca pode ser gerada diretamente do código fonte usando a ferramenta Doxygen:
# in build directory
make doc
google-chrome doc/html/index.htmlA biblioteca json-c é construída com CMake, que pode ter algumas opções.
| Variável | Tipo | Descrição |
|---|---|---|
| CMAKE_INSTALL_PREFIX | Corda | O local de instalação. |
| CMAKE_BUILD_TYPE | Corda | O padrão é "depurar". |
| BUILD_SHARED_LIBS | Bool | A compilação padrão gera uma biblioteca dinâmica (dll/so). Defina como OFF para criar apenas uma biblioteca estática. |
| BUILD_STATIC_LIBS | Bool | A compilação padrão gera uma biblioteca estática (lib/a). Defina como OFF para criar apenas uma biblioteca compartilhada. |
| DISABLE_STATIC_FPIC | Bool | O padrão cria código independente de posição. Defina como OFF para criar apenas uma biblioteca compartilhada. |
| DISABLE_BSYMBOLIC | Bool | Desative o uso de funções -Bsymbolic. |
| DISABLE_THREAD_LOCAL_STORAGE | Bool | Desative o uso de armazenamento local de thread (HAVE___THREAD). |
| DISABLE_WERROR | Bool | Desative o uso de -Werror. |
| DISABLE_EXTRA_LIBS | Bool | Desative o uso de bibliotecas extras, libbsd |
| DISABLE_JSON_POINTER | Bool | Omita o suporte json_pointer da compilação. |
| ENABLE_RDRAND | Bool | Habilite a semente de hash RNG de hardware RDRAND. |
| ATIVAR_THREADING | Bool | Habilite o suporte a threading parcial. |
| OVERRIDE_GET_RANDOM_SEED | Corda | Um bloco de código para usar em vez da implementação padrão de json_c_get_random_seed(), por exemplo, em plataformas incorporadas onde nem mesmo o fallback para time() funciona. Deve ser uma única linha. |
Passe essas opções como -D na linha de comando do CMake.
# build a static library only
cmake -DBUILD_SHARED_LIBS=OFF ..Embora json-c não suporte acesso totalmente multithread a árvores de objetos, ele possui algum código para ajudar a tornar seu uso em programas threaded um pouco mais seguro. Atualmente, isso está limitado ao uso de operações atômicas para json_object_get() e json_object_put().
Como isso pode ter um impacto no desempenho, pelo menos 3x mais lento, de acordo com https://stackoverflow.com/a/11609063, ele está desabilitado por padrão. Você pode ativá-lo ajustando seu comando cmake com: -DENABLE_THREADING=ON
Separadamente, a função hash padrão usada para chaves de campo de objeto, lh_char_hash, usa uma operação de comparação e troca para garantir que a semente aleatória seja gerada apenas uma vez. Como esta é uma operação única, ela é sempre compilada quando a operação comparar e trocar estiver disponível.
Para aqueles familiarizados com o antigo método autoconf/autogen.sh/configure, existe um script wrapper cmake-configure para facilitar a transição para o cmake.
mkdir build
cd build
../cmake-configure --prefix=/some/install/path
makecmake-configure pode ter algumas opções.
| opções | Descrição |
|---|---|
| prefixo=PREFIXO | instale arquivos independentes de arquitetura no PREFIX |
| habilitar threading | Habilite o código para suportar o uso parcialmente multithread |
| habilitar-rdrand | Habilite a geração de sementes de hash RNG de hardware RDRAND em plataformas x86/x64 suportadas. |
| habilitar-compartilhado | construir bibliotecas compartilhadas [padrão = sim] |
| habilitar-estático | construir bibliotecas estáticas [padrão = sim] |
| desativar-B simbólico | Evite vincular com -Bsymbolic-function |
| desativar erro | Evite tratar os avisos do compilador como erros fatais |
Por padrão, se o valgrind estiver disponível, a execução de testes o utiliza. Isso pode retardar consideravelmente os testes, então para desativá-lo use:
export USE_VALGRIND=0Para executar testes, é recomendado um diretório de compilação separado:
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 Se um teste falhar, verifique Testing/Temporary/LastTest.log , tests/testSubDir/${testname}/${testname}.vg.out e outros arquivos semelhantes. Se houver saída insuficiente, tente:
VERBOSE=1 CTEST_OUTPUT_ON_FAILURE=1 make testou
JSONC_TEST_TRACE=1 make teste verifique os arquivos de log novamente.
vcpkgVocê pode baixar e instalar JSON-C usando o gerenciador de dependência vcpkg:
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh
./vcpkg integrate install
vcpkg install json-c
A porta JSON-C no vcpkg é mantida atualizada pelos membros da equipe da Microsoft e pelos colaboradores da comunidade. Se a versão estiver desatualizada, crie um problema ou solicitação pull no repositório vcpkg.
A construção no Android agora é particularmente bem suportada, mas houve alguns relatos de sucesso usando 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 Se o seu sistema tiver pkgconfig , você pode simplesmente adicionar isto ao seu makefile :
CFLAGS += $( shell pkg-config --cflags json-c)
LDFLAGS += $( shell pkg-config --libs json-c) Sem pkgconfig , você poderia fazer algo assim:
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-cSe o seu projeto 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 você pode incluir json.h ou, preferencialmente, um dos seguintes arquivos de cabeçalho mais específicos:
json_object_object_foreach() em json_object.h)Para obter uma lista completa de cabeçalhos, consulte files.html
O tipo principal em json-c é json_object. Ele descreve uma árvore contada de referência de objetos json que são criados analisando texto com um json_tokener (ou seja, json_tokener_parse_ex() ) ou criando (com json_object_new_object() , json_object_new_int() , etc...) e adicionando (com json_object_object_add() , json_object_array_add() , etc...) individualmente. Normalmente, cada objeto na árvore terá uma referência, de seu pai. Quando terminar a árvore de objetos, você chama json_object_put() apenas no objeto raiz para liberá-lo, que recorre a quaisquer objetos filhos que chamam json_object_put() em cada um deles.
Você pode obter uma referência a um único filho ( json_object_object_get() ou json_object_array_get_idx() ) e usar esse objeto desde que seu pai seja válido.
Se você precisa que um objeto filho viva mais que seu pai, você pode incrementar a contagem de referência do filho ( json_object_get() ) para permitir que ele sobreviva ao pai sendo liberado ou removido de seu pai ( json_object_object_del() ou json_object_array_del_idx() )
Ao analisar texto, o objeto json_tokener é independente do json_object que ele retorna. Ele pode ser alocado ( json_tokener_new() ), usado uma ou várias vezes ( json_tokener_parse_ex() e liberado ( json_tokener_free() ) enquanto os objetos json_object permanecem ativos.
Uma árvore json_object pode ser serializada de volta em uma string com json_object_to_json_string_ext() . A string retornada só é válida até a próxima chamada "to_json_string" nesse mesmo objeto. Além disso, ele é liberado quando o json_object é liberado.
