Repository files navigation

Cista++ is a simple, open source (MIT license) C++17 compatible way of (de-)serializing C++ data structures.

Single header - no dependencies. No macros. No source code generation.

• Raw performance - use your native structs. Supports modification/resizing of deserialized data!
• Supports complex and cyclic data structures including cyclic references, recursive data structures, etc.
• Save 50% memory: serialize directly to the filesystem if needed, no intermediate buffer required.
• Fuzzing-checked though continuous fuzzing using LLVMs LibFuzzer.
• Comes with a serializable high-performance hash map and hash set implementation based onGoogle's Swiss Table.
• Reduce boilerplate code: automatic derivation of hash and equality functions.
• Built-in optional automatic data structure versioning through recursive type hashing.
• Optional check sum to prevent deserialization of corrupt data.
• Compatible with Clang, GCC, and MSVC

The underlying reflection mechanism can be used inother ways, too!

Examples:

Download thelatest release and try it out.

Simple example writing to a buffer:

namespacedata= cista::raw;structmy_struct {// Define your struct.int a_{0};structinner {      data::string b_;  } j;};std::vector<unsignedchar> 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"});

Advanced example writing a hash map to a memory mapped file:

namespacedata= cista::offset;constexprautoconst MODE =// opt. versioning + check sum    cista::mode::WITH_VERSION | cista::mode::WITH_INTEGRITY;structpos {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);

Advanced example showing support for non-aggregate types like derived classes or classes with custom constructors:

namespacedata= cista::offset;constexprauto MODE = cista::mode::WITH_VERSION;structparent {parent() =default;explicitparent(int a) : x_{a}, y_{a} {}autocista_members() {returnstd::tie(x_, y_); }int x_, y_;};structchild : parent {child() =default;explicitchild(int a) : parent{a}, z_{a} {}autocista_members() {returnstd::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

Have a look at thebenchmark repository for more details.

Reader and writer should have the same pointer width. Loading data on systems with a different byte order (endianess) is supported.Examples:

• Asset loading for all kinds of applications (i.e. game assets, GIS data, large graphs, etc.)
• Transferring data over network
• shared memory applications

Currently, only C++17 software can read/write data.But it should be possible to generate accessorsfor other programming languages, too.

If you need to be compatible with other programming languagesor require protocol evolution (downward compatibility)you should look for another solution:

• Protocol Buffers
• Cap’n Proto
• Flatbuffers
• cereal
• Boost Serialization
• MessagePack
• tser
• ... many more

• Installation and Usage
• Serialization Reference
• Custom (De-)Serialization Functions
• Data Structure Versioning
• Hash Containers
  • Hashing Framework
  • Equality Framework
  • Benchmark
• Security

Feel free to contribute (bug reports, pull requests, etc.)!