cista Download - cista Source Code Download

cista

C/C++

v0.15

Herunterladen

Einfache C ++ - Serialisierung und Reflexion.

CISTA ++ ist eine einfache Open-Source-(MIT-Lizenz) C ++ 17 kompatible Methode für (De-) serialisierende C ++ -Datenstrukturen.

Single Header - Keine Abhängigkeiten. Keine Makros. Keine Quellcodegenerierung.

Rohleistung - Verwenden Sie Ihre nativen Strukturen. Unterstützt die Änderung/Größe von Deserialisierten Daten!
Unterstützt komplexe und zyklische Datenstrukturen, einschließlich zyklischer Referenzen, rekursiven Datenstrukturen usw.
Speichern Sie 50% Speicher: Bei Bedarf direkt im Dateisystem serialisieren, kein Zwischenpuffer erforderlich.
Fuzzing-überprüftes, aber kontinuierliches Fuzzing mit LLVMS libfuzzer.
Kommt mit einer serialisierbaren Hochleistungs-Hash-Karte und einer Hash-Set-Implementierung basierend auf der Schweizer Tabelle von Google.
Reduzieren Sie den Boilerplate -Code: Automatische Ableitung von Hash- und Gleichstellungsfunktionen.
Integrierte optionale automatische Datenstrukturversionierung durch rekursives Hashing vom Typ.
Optionale Überprüfung der Summe, um die Deserialisierung von beschädigten Daten zu verhindern.
Kompatibel mit Clang, GCC und MSVC

Der zugrunde liegende Reflexionsmechanismus kann auch auf andere Weise verwendet werden!

Beispiele:

Laden Sie die neueste Version herunter und probieren Sie sie aus.

Einfaches Beispiel, das auf einen Puffer schreibt:

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

Erweitertes Beispiel Schreiben einer Hash -Karte in eine von Speicher zugeordnete Datei:

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

Erweitertes Beispiel, das Unterstützung für nicht-aggregate Typen wie abgeleitete Klassen oder Klassen mit benutzerdefinierten Konstruktoren zeigt:

 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

Schauen Sie sich das Benchmark -Repository an, um weitere Informationen zu erhalten.

Bibliothek	Serialisieren	Deserialisieren	Schnelle Deserialisierung	Traverse	Deserialize & Traverse	Größe
Cap'n Proto	105 ms	0,002 ms	0,0 ms	356 ms	353 ms	50,5 m
Getreide	239 ms	197.000 ms	- -	125 ms	322 ms	37,8 m
Cista ++ `offset`	72 ms	0,053 ms	0,0 ms	132 ms	132 ms	25,3 m
Cista ++ `raw`	3555 ms	68.900 ms	21,5 ms	112 ms	133 ms	176,4m
Flatbuffer	2349 ms	15.400 ms	0,0 ms	136 ms	133 ms	63,0 m

Anwendungsfälle

Leser und Schriftsteller sollten die gleiche Zeigerbreite haben. Das Laden von Daten zu Systemen mit einer anderen Byte -Reihenfolge (Endialtess) wird unterstützt. Beispiele:

Asset Loading für alle Arten von Anwendungen (dh Game Assets, GIS -Daten, große Grafiken usw.)
Daten über das Netzwerk übertragen
gemeinsam genutzte Speicheranwendungen

Derzeit kann nur C ++ 17 Software Daten lesen/schreiben. Es sollte jedoch auch möglich sein, Zubehör für andere Programmiersprachen zu generieren.

Alternativen

Wenn Sie mit anderen Programmiersprachen kompatibel sein müssen oder eine Protokollentwicklung (Abwärtskompatibilität) erfordern, sollten Sie nach einer anderen Lösung suchen: