Unduh cista - Unduh Kode Sumber cista

cista

C/C++

v0.15

Unduh

Serialisasi & Refleksi C ++ Sederhana.

Cista ++ adalah sumber yang sederhana dan terbuka (lisensi MIT) C ++ 17 cara yang kompatibel dari (de-) serialisasi struktur data C ++.

Single Header - Tidak ada dependensi. Tidak ada makro. Tidak ada pembuatan kode sumber.

Kinerja mentah - Gunakan struct asli Anda. Mendukung Modifikasi/Ubah Ulang Data Deserialized!
Mendukung struktur data kompleks dan siklik termasuk referensi siklik, struktur data rekursif, dll.
Simpan 50% memori: Serial langsung ke sistem file jika diperlukan, tidak diperlukan buffer perantara.
Fuzzing-checked meskipun terus menerus fuzzing menggunakan llvms libfuzzer.
Dilengkapi dengan peta hash kinerja tinggi yang dapat diserialisasi dan implementasi hash set berdasarkan tabel Swiss Google.
Kurangi kode boilerplate: Derivasi otomatis dari fungsi hash dan kesetaraan.
Versi struktur data otomatis opsional bawaan melalui hashing tipe rekursif.
Jumlah pemeriksaan opsional untuk mencegah deserialisasi data korup.
Kompatibel dengan dentang, GCC, dan MSVC

Mekanisme refleksi yang mendasarinya juga dapat digunakan dengan cara lain!

Contoh:

Unduh rilis terbaru dan coba.

Contoh sederhana menulis ke 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 " });

Contoh Lanjutan Menulis peta hash ke file yang dipetakan memori:

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

Contoh lanjutan yang menunjukkan dukungan untuk jenis non-agregat seperti kelas atau kelas yang diturunkan dengan konstruktor khusus:

 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

Tolok ukur

Lihatlah repositori benchmark untuk detail lebih lanjut.

Perpustakaan	Serialize	Deserialize	Deserialize Cepat	Melintasi	Deserialize & Traverse	Ukuran
Proto Cap'n	105 ms	0,002 ms	0,0 ms	356 ms	353 ms	50.5m
sereal	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
Flatbuffer	2349 ms	15.400 ms	0,0 ms	136 ms	133 ms	63.0m

Menggunakan kasus

Pembaca dan penulis harus memiliki lebar pointer yang sama. Memuat data pada sistem dengan urutan byte yang berbeda (Endianess) didukung. Contoh:

Pemuatan aset untuk semua jenis aplikasi (yaitu aset game, data GIS, grafik besar, dll.)
Mentransfer data melalui jaringan
aplikasi memori bersama

Saat ini, hanya perangkat lunak C ++ 17 yang dapat membaca/menulis data. Tetapi harus dimungkinkan untuk menghasilkan aksesor untuk bahasa pemrograman lainnya juga.