Description
Cista++ is a simple, open source (MIT license) C++17 high-performance zero-copy way of (de-)serializing C++ data structures.
Simple C++ Serialization & Reflection. alternatives and similar libraries
Based on the "Serialization" category.
Alternatively, view cista alternatives based on common mentions on social networks and blogs.
-
protobuf
Protocol Buffers - Google's data interchange format -
FlatBuffers
FlatBuffers: Memory Efficient Serialization Library -
cereal
A C++11 library for serialization -
Magic Enum C++
Static reflection for enums (to string, from string, iteration) for modern C++, work with any enum type without any macro or boilerplate code -
MessagePack
MessagePack implementation for C and C++ / msgpack.org[C/C++] -
SimpleBinaryEncoding
Simple Binary Encoding (SBE) - High Performance Message Codec -
protobuf-c
Protocol Buffers implementation in C -
Bond
Bond is a cross-platform framework for working with schematized data. It supports cross-language de/serialization and powerful generic mechanisms for efficiently manipulating data. Bond is broadly used at Microsoft in high scale services. -
Nameof C++
Nameof operator for modern C++, simply obtain the name of a variable, type, function, macro, and enum -
The IOD Library
Meta programming utilities for C++14. Merged in matt-42/lithium -
cppcodec
Header-only C++11 library to encode/decode base64, base64url, base32, base32hex and hex (a.k.a. base16) as specified in RFC 4648, plus Crockford's base32. MIT licensed with consistent, flexible API. -
protozero
Minimalist protocol buffer decoder and encoder in C++ -
Boost.Serialization
Boost.org serialization module -
config-loader
Simple C++ Config Loader Framework(Serialization & Reflection) -
LeapSerial
The Leap Motion cross-format, cross-platform declarative serialization library -
cppbor
An implementation of cbor using C++ 17 variants
Analyze your C and C++ projects with just one click.
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of Simple C++ Serialization & Reflection. or a related project?
README
Simple C++ Serialization & Reflection.
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 on Google'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 in other ways, too!
Examples:
Download the latest release and try it out.
Simple example writing to a 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"});
Advanced example writing a hash map to a memory mapped file:
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);
Benchmarks
Have a look at the benchmark repository for more details.
Library | Serialize | Deserialize | Fast Deserialize | Traverse | Deserialize & Traverse | Size |
---|---|---|---|---|---|---|
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 |
Cista++ offset |
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 |
Flatbuffers | 2349 ms | 15.400 ms | 0.0 ms | 136 ms | 133 ms | 63.0M |
Use Cases
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 accessors for other programming languages, too.
Alternatives
If you need to be compatible with other programming languages or require protocol evolution (downward compatibility) you should look for another solution:
Documentation
- Installation and Usage
- Serialization Reference
- Custom (De-)Serialization Functions
- Data Structure Versioning
- Hash Containers
- Security
Contribute
Feel free to contribute (bug reports, pull requests, etc.)!
*Note that all licence references and agreements mentioned in the Simple C++ Serialization & Reflection. README section above
are relevant to that project's source code only.