Téléchargement cista - Téléchargement du code source cista

cista

C/C++

v0.15

Télécharger

Sérialisation et réflexion C ++ simple.

CISTA ++ est une voie compatible simple et open source (licence MIT) C ++ 17 de (de-) sérialiser les structures de données C ++.

En-tête unique - pas de dépendances. Pas de macros. Aucune génération de code source.

Performances brutes - Utilisez vos structures natives. Prend en charge la modification / redimensionnement des données désérialisées!
Prend en charge les structures de données complexes et cycliques, y compris les références cycliques, les structures de données récursives, etc.
Enregistrez 50% de mémoire: sérialiser directement au système de fichiers si nécessaire, aucun tampon intermédiaire requis.
Fuzzing vérifiée mais continue à l'aide de LLVMS libfuzzer.
Livré avec une carte de hachage haute performance sérialisable et une mise en œuvre de l'ensemble de hachage basé sur le tableau suisse de Google.
Réduisez le code du chaudron: dérivation automatique des fonctions de hachage et d'égalité.
Version de structure de données automatique en option intégrée via le hachage de type récursif.
Somme de vérification facultative pour empêcher la désérialisation des données corrompues.
Compatible avec Clang, GCC et MSVC

Le mécanisme de réflexion sous-jacent peut également être utilisé d'une autre manière!

Exemples:

Téléchargez la dernière version et essayez-le.

Exemple simple écrivant dans un tampon:

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

Exemple avancé Écrivant une carte de hachage dans un fichier mappé de mémoire:

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

Exemple avancé montrant la prise en charge des types de non-agrégats comme des classes ou des classes dérivées avec des constructeurs personnalisés:

 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

Repères

Jetez un œil au référentiel de référence pour plus de détails.

Bibliothèque	Sérialiser	Désérialiser	Désérialiser rapidement	Traverser	Désérialiser et traverser	Taille
Cap'n Proto	105 ms	0,002 ms	0,0 ms	356 ms	353 ms	50,5 m
céréale	239 MS	197 000 ms	-	125 ms	322 ms	37,8 m
`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,4 m
Pelures à plat	2349 ms	15.400 ms	0,0 ms	136 ms	133 ms	63,0 m

Cas d'utilisation

Lecteur et écrivain doivent avoir la même largeur de pointeur. Le chargement des données sur les systèmes avec un ordre d'octet différent (ENIAND) est pris en charge. Exemples:

Chargement des actifs pour toutes sortes d'applications (c.-à-d. Actifs de jeu, données SIG, gros graphiques, etc.)
Transfert de données sur le réseau
Applications de mémoire partagées

Actuellement, seul le logiciel C ++ 17 peut lire / écrire des données. Mais il devrait également être possible de générer des accessoires pour d'autres langages de programmation.

Alternatives

Si vous devez être compatible avec d'autres langages de programmation ou nécessiter une évolution du protocole (compatibilité vers le bas), vous devez rechercher une autre solution: