cxon
Release 0.64.0
CXONCXON é uma interface de serialização C ++CXON implementa JSON ( UTF-8 codificado) como formato de serialização (um exemplo de formato de dados baseado em texto)CXON implementa CBOR como formato de serialização (exemplo de um formato de dados binários)CXON é fácil de estender para diferentes formatos e tipos com cabeça de zeroCXON é uma biblioteca C++11 , independente e compacta e compacta, somente Embora CXON seja uma biblioteca de serialização, seu objetivo é realmente competir com JSON / CBOR / etc. bibliotecas como Boost.JSON / RapidJSON / etc. E sua principal vantagem é que nenhum tipo intermediário é necessário para representar os dados - qualquer tipo C++ que o corresponda semanticamente possa ser usado.
# include " cxon/json.hxx "
# include " cxon/lib/std/vector.hxx " // for <vector>
# include < cassert >
int main () {
std::vector< int > cxx; // or std::array, std::list, std::set, etc.
// the input is a JSON array, semantically a list of integers
auto result = cxon::from_bytes (cxx, " [1, 2, 3] " );
assert (result);
// the data is loaded successfully, no additional semantic validation is needed, so
assert (cxx == (std::vector< int > { 1 , 2 , 3 }));
}Deserialização bem -sucedida significa que a entrada é sintaticamente e semanticamente correta.
Outras bibliotecas representam dados arbitrários com tipo polimórfico (chamado DOM , value , etc.), e a análise bem -sucedida dos dados de entrada significa apenas que eles estão sintaticamente corretos.
// pseudo code
value_type json = json_lib::parse( " [1, 2, 3] " );
assert (json.has_parsing_errors()); // check for syntax errors
// check the semantics, expected is a list of integers
assert (json.is_array()); // check the type
auto & array = json.get_array();
assert ( // check the values
array.size() > ... &&
array[0].is_integer() &&
array[1].is_integer() &&
array[2].is_integer() &&
...
);
// the input is semantically correct, but
// the values still need special attention
int x0 = array[ 0 ].get_integer(); // it's an int, but not quite
... Para ajudar com isso, algumas das bibliotecas fornecem utilitários para converter o tipo de valor em um tipo C++ - por exemplo, Boost.JSON fornece value_from / value_to .
Para completude, CXON também fornece tipos polimórficos (chamados node ) para os formatos suportados que correspondem à funcionalidade fornecida por essas bibliotecas.
O desempenho é frequentemente importante e é enfatizado por muitas bibliotecas e, a esse respeito, CXON está próximo das alternativas.
Muitas bibliotecas enfatizam o desempenho de serialização e desserialização de ponto flutuante. CXON usa <charconv> por padrão (com uma implementação de fallback para C++11 ), mas pode ser configurado para usar boost::charconv , definindo CXON_USE_BOOST_CHARCONV .
Observe que as bibliotecas baseadas em tipos polimórficas têm validação e usam despesas gerais que devem ser levadas em consideração.
O gerenciamento de memória é frequentemente importante. CXON não aloca em geral, cabe aos tipos fornecidos.
No exemplo acima, o gerenciamento de memória será tratado completamente pelo std::vector e seu alocador.
Os tipos polimórficos fornecidos pelo CXON são compatíveis com alocatadore.
CXON não é lançado , desde que os serializadores envolvidos não joguem.
CXON define e implementa uma interface semelhante a C++17 's <charconv> .
CXON estende a interface de <charconv> com:
Format traits )Interface ) As características podem ter estado ou sem estado, permitindo formatos complexos arbitrários.
Os parâmetros nomeados podem ser tempo de compilação ou tempo de execução, fornecendo flexibilidade para as implementações.
Mais sobre a interface pode ser encontrada no MANUAL .
CXON suporta boa parte dos tipos de bibliotecas fundamentais, compostos e padrão do C++ .
CXON pode ser estendido para tipos arbitrários, usando métodos intrusivos e não intrusivos.
Mais detalhes podem ser encontrados no MANUAL .
JSON A implementação está em conformidade com RFC8259 / ECMA-404 .
CXON/JSON também fornece um tipo polimórfico cxon::json::node , que pode representar dados JSON arbitrários.
CBOR A implementação está em conformidade com RFC7049 .
CXON/CBOR também fornece um cxon::cbor::node , que pode representar dados arbitrários CBOR .
CXCF CXCF é um formato de configuração simples derivado do JSON .
Deserialização CXON usando a conversão de número padrão ( <charconv> ).
Serialização CXON usando a conversão de número padrão ( <charconv> ).
CXON Tamanho binário e tempos de compilação.
Informações sobre os benchmarks e resultados adicionais de referência podem ser encontrados aqui.
Nota: Boost.json e Rapidjson usam os algoritmos de análise de análise mais rápida, mas um pouco imprecisa, por padrão. Nos benchmarks, eles são testados com a precisão total ativada.
Dados os resultados de referência e assumindo que as bibliotecas CXON são comparadas a serem razoavelmente bem escritas, pode-se dizer que CXON satisfaz o princípio da cabeça zero.
CXON requer compilador compilador compilador C++11 , testado com g++ >= 5 , clang++ >= 4.0 e msvc++ >= 19.16 (consulte as compilações).
CXON está usando <charconv> para conversões numéricas, se disponível.
Caso contrário, C++17 usado uma implementação de fallback (baseada em strto* e sprintf ).
Se CXON_USE_BOOST_CHARCONV for definido, boost::charconv será usado. Isso fornecerá um bom impulso de desempenho para C++11/14 e algumas implementações anteriores de <charconv> .
CXON é uma biblioteca somente para cabeçalho - copie os cabeçalhos necessários ou use o makefile fornecido para instalá -lo nos sistemas POSIX :
$ sudo make installou execute as suítes de teste com:
$ make check Qualquer tipo de contribuição (feedback, sugestões, código, testes, documentação etc.) é bem -vindo.
Contate via github (crie um problema, mesmo que seja apenas uma pergunta ou comentário) ou via correio.
Distribuído sob a licença do MIT. Consulte LICENSE para obter mais informações.
Github
