Download cista - Download do código fonte cista

cista

C/C++

v0.15

Baixar

Serialização e reflexão simples C ++.

O CISTA ++ é uma maneira compatível de código aberto (Licença MIT) 17 de código aberto de (des) serializando estruturas de dados C ++.

Cabeçalho único - sem dependências. Sem macros. Sem geração de código -fonte.

Desempenho bruto - use suas estruturas nativas. Suporta modificação/redimensionamento de dados desserializados!
Suporta estruturas de dados complexas e cíclicas, incluindo referências cíclicas, estruturas de dados recursivas, etc.
Salve 50% de memória: serialize diretamente no sistema de arquivos, se necessário, não é necessário buffer intermediário.
Verificou a difamação, apesar de contínua, usando LLVMs libfuzzer.
Vem com um mapa de hash de alto desempenho serializável e implementação de hash com base na tabela suíça do Google.
Reduza o código da caldeira: derivação automática das funções de hash e igualdade.
Versão opcional de estrutura de dados automática opcional por meio de hash do tipo recursivo.
Soma opcional de verificação para impedir a desertalização de dados corruptos.
Compatível com CLANG, GCC e MSVC

O mecanismo de reflexão subjacente também pode ser usado de outras maneiras!

Exemplos:

Faça o download do lançamento mais recente e experimente.

Exemplo simples escrevendo para um buffer:

 namespace data = cista::raw;
struct my_struct {  // Define your struct.
  int a_{ 0 };
  struct inner {
      data::string b_;
  } j;
};

std::vector< unsigned char > buf;
{  // Serialize.
  my_struct obj{ 1 , {data::string{ " test " }}};
  buf = cista::serialize (obj);
}

// Deserialize.
auto deserialized = cista::deserialize<my_struct>(buf);
assert (deserialized->j.b_ == data::string{ " test " });

Exemplo avançado escrevendo um mapa de hash para um arquivo mapeado de memória:

 namespace data = cista::offset;
constexpr auto const MODE =  // opt. versioning + check sum
    cista::mode::WITH_VERSION | cista::mode::WITH_INTEGRITY;

struct pos { int x, y; };
using pos_map =  // Automatic deduction of hash & equality
    data::hash_map<data::vector<pos>,
                   data::hash_set<data::string>>;

{  // Serialize.
  auto positions =
      pos_map{{{{ 1 , 2 }, { 3 , 4 }}, { " hello " , " cista " }},
              {{{ 5 , 6 }, { 7 , 8 }}, { " hello " , " world " }}};
  cista::buf mmap{cista::mmap{ " data " }};
  cista::serialize<MODE>(mmap, positions);
}

// Deserialize.
auto b = cista::mmap( " data " , cista::mmap::protection::READ);
auto positions = cista::deserialize<pos_map, MODE>(b);

Exemplo avançado mostrando suporte para tipos não agregados, como classes ou classes derivadas com construtores personalizados:

 namespace data = cista::offset;
constexpr auto MODE = cista::mode::WITH_VERSION;

struct parent {
  parent () = default ;
  explicit parent ( int a) : x_{a}, y_{a} {}
  auto cista_members () { return std::tie (x_, y_); }
  int x_, y_;
};
struct child : parent {
  child () = default ;
  explicit child ( int a) : parent{a}, z_{a} {}
  auto cista_members () {
    return std::tie (* static_cast <parent*>( this ), z_);
  }
  int z_;
};

/*
 * Automatically defaulted for you:
 *   - de/serialization
 *   - hashing (use child in hash containers)
 *   - equality comparison
 *   - data structure version ("type hash")
 */
using t = data::hash_map<child, int >;

// ... usage, serialization as in the previous examples

Benchmarks

Dê uma olhada no repositório de referência para obter mais detalhes.

Biblioteca	Serializar	Desserialize	Desserialize rápido	Atravessar	Desserialize e Traverse	Tamanho
Cap'n Proto	105 ms	0,002 ms	0,0 ms	356 ms	353 ms	50,5m
cereal	239 ms	197.000 ms	-	125 ms	322 ms	37,8m
`offset` cista ++	72 ms	0,053 ms	0,0 ms	132 ms	132 ms	25,3m
Cista ++ `raw`	3555 ms	68.900 ms	21,5 ms	112 ms	133 ms	176,4m
Planície	2349 MS	15.400 ms	0,0 ms	136 ms	133 ms	63,0m

Casos de uso

O leitor e o escritor devem ter a mesma largura do ponteiro. O carregamento de dados sobre sistemas com uma ordem de byte diferente (Endianess) é suportado. Exemplos:

Carregamento de ativos para todos os tipos de aplicativos (por exemplo, ativos de jogo, dados GIS, gráficos grandes, etc.)
Transferindo dados sobre a rede
Aplicativos de memória compartilhada

Atualmente, apenas o software C ++ 17 pode ler/gravar dados. Mas deve ser possível gerar acessadores para outras linguagens de programação também.

Alternativas

Se você precisar ser compatível com outras linguagens de programação ou exigir evolução do protocolo (compatibilidade descendente), procure outra solução: