Descarga cista - Descarga del código fuente cista

cista

C/C++

v0.15

Descargar

Serialización y reflexión simple de C ++.

CISTA ++ es una forma simple y de código abierto (licencia MIT) C ++ 17 forma compatible de (des-) serializar las estructuras de datos de C ++.

Encabezado único: sin dependencias. Sin macros. No hay generación de código fuente.

Rendimiento en bruto: use sus estructuras nativas. ¡Admite la modificación/cambio de tamaño de datos deserializados!
Admite estructuras de datos complejas y cíclicas que incluyen referencias cíclicas, estructuras de datos recursivas, etc.
Guarde el 50% de memoria: serialice directamente al sistema de archivos si es necesario, no se requiere un búfer intermedio.
Fuzzing verificado a través de la difusa continua usando LLVMS libfuzzer.
Viene con un mapa hash de alto rendimiento serializable y una implementación establecida de hash basada en la tabla suiza de Google.
Reduzca el código de la caldera: derivación automática del hash y las funciones de igualdad.
Versiones de estructura de datos automática opcional incorporada a través de hash de tipo recursivo.
Suma de verificación opcional para evitar la deserialización de los datos corruptos.
Compatible con Clang, GCC y MSVC

¡El mecanismo de reflexión subyacente también se puede usar de otras maneras!

Ejemplos:

Descargue el último lanzamiento y pruébelo.

Simple Ejemplo escribiendo a un búfer:

 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 " });

Ejemplo avanzado Escribir un mapa hash en un archivo mapeado de memoria:

 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);

Ejemplo avanzado que muestra soporte para tipos no agregados como clases o clases derivadas con constructores 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

Puntos de referencia

Eche un vistazo al repositorio de referencia para obtener más detalles.

Biblioteca	Fabricar en serie	Deserializar	Deserializar rápidamente	Atravesar	Deserializar y recorrer	Tamaño
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
Plateros	2349 ms	15.400 ms	0.0 ms	136 ms	133 MS	63.0m

Casos de uso

El lector y el escritor deben tener el mismo ancho de puntero. Se admite la carga de datos en sistemas con un orden de byte diferente (endianess). Ejemplos:

Carga de activos para todo tipo de aplicaciones (es decir, activos de juego, datos SIG, gráficos grandes, etc.)
Transferir datos a través de la red
Aplicaciones de memoria compartidas

Actualmente, solo el software C ++ 17 puede leer/escribir datos. Pero también debería ser posible generar accesorios para otros lenguajes de programación.

Alternativas

Si necesita ser compatible con otros lenguajes de programación o requiere evolución del protocolo (compatibilidad hacia abajo), debe buscar otra solución: