Yet Another Serialization

Build Status Build status

YAS

Yet Another Serialization

-Time

  • YAS is created as a replacement of boost.serialization because of its insufficient speed of serialization (benchmark 1, benchmark 2)
  • YAS is header only library
  • YAS does not depend on third-party libraries or boost
  • YAS require C++11 support
  • YAS binary archives is endian independent

Supported the following types of archives:

  • binary
  • text
  • json (not fully comply)

Supported the following compilers:

  • GCC : 4.8.5, ... - 32/64 bit
  • MinGW: 4.8.5, ... - 32/64 bit
  • Clang: 3.5, ... - 32/64 bit
  • Intel: (untested)
  • MSVC : 2017(in c++14 mode), ... - 32/64 bit
  • Emscripten: 1.38 (clang version 6.0.1)

Samples

The easiest way to save and load some object or vars is to use the yas::save() and yas::load() functions like this:

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>

int main() {
    int a = 3, aa{};
    short b = 4, bb{};
    float c = 3.14, cc{};
    
    constexpr std::size_t flags = 
         yas::mem // IO type
        |yas::json; // IO format
    
    auto buf = yas::save<flags>(
        YAS_OBJECT("myobject", a, b, c)
    );
    
    // buf = {"a":3,"b":4,"c":3.14}
    
    yas::load<flags>(buf,
        YAS_OBJECT_NVP("myobject"
            ,("a", aa)
            ,("b", bb)
            ,("c", cc)
        )
    );
    // a == aa && b == bb && c == cc;
}

The IO type can be one of yas::mem or yas::file. The IO format can be one of yas::binary or yas::text or yas::json.

The YAS_OBJECT()/YAS_OBJECT_NVP()/YAS_OBJECT_STRUCT()/YAS_OBJECT_STRUCT_NVP() macro are declared here, example use is here.

More examples you can see here.

TODO:

  • protobuf/messagepack support
  • limits
  • objects versioning

Support the project

You can support the YAS project by donating:

  • BTC: 12rjx6prAxwJ1Aep6HuM54At9wDvSCDbSJ
  • ETH: 0x62719DDEc96C513699a276107622C73F6cAcec47

Serialization for the following types is supported:

Projects using YAS

  • Ufochain: a mimblewimble implementation of crypto currency using X17r algorithm
  • Kvant: Kvant - is an original project using the consensus of MimbleWimble, due to which maximum anonymity and security were achieved
  • zkPoD-lib: zkPoD-lib is the underlying core library for zkPoD system. It fully implements PoD (proof of delivery) protocol and also provides a CLI interface together with Golang bindings
  • Litecash: Litecash is the next generation scalable, confidential cryptocurrency based on an elegant and innovative Mimblewimble protocol
  • K3: K3 is a programming language for building large-scale data systems
  • vistle: Software Environment for High-Performance Simulation and Parallel Visualization
  • LGraph: Live Graph infrastructure for Synthesis and Simulation
  • Beam: BEAM is a next generation scalable, confidential cryptocurrency based on an elegant and innovative Mimblewimble protocol
  • libfon9: C++11 Cross-platform infrastructure for Order Management System
  • iris-crypt: Store Node.js modules encrypted in a package file
  • cppan: Class members annotations for C++
  • GeekSys company: GeekSys is using YAS to serialize features from images
Owner
niXman
C++ for bitcoin/ethereum ([email protected])
niXman
Comments
  • Сериализация конечного автомата Ахо-Корасик

    Сериализация конечного автомата Ахо-Корасик

    А можно, используя YAS, сериализовать автомат такого вида? Если да, то ткните в направлении мануала хоть какого-то.

    	class BorNode {
    	public:
    		map<const char, BorNode *>links;
    		BorNode *fail; 
    		BorNode *term;
    		int out;
    	};
    
  • zero copy and seek stream

    zero copy and seek stream

    Hello,

    I've looked through the docs and examples and this library fits very well with my needs but I'm not finding an important feature which is to be able to do zero copy serialization and seek inside data out stream.

    I'd like to use preallocated buffer for serialization, and also be able to seek inside this buffer and serialize without dynamic allocation.

    Example:

        yas::mem_ostream                             os(size); <= preallocated memory
        yas::binary_oarchive<yas::mem_ostream, opts> oa(os);
        oa&                                          Packet{ 1, 2, 3, 4 };
        os.seek(offset); <= seek to some offset in memory
        oa&                                          Packet{ 1, 2, 3, 4 };
        os.clear(); <= Reset to zero offset and memset to zeros
        etc...
    

    Is there a way to do this or something to add to the library?

    Thanks, Best Mark

  • android / linux headers are mismatching

    android / linux headers are mismatching

    I'm using yas::binary_iarchiveyas::file_istream and yas::binary_oarchiveyas::file_ostream to, respectively, WRITE on Android (ARM v7a) and to READ on Linux (x86_64).

    Android binary file contains header "yas5800", but when I try to read it from Linux it is throwing an exception:

    what():  .../yas/include/yas/detail/io/information.hpp(198): incompatible archive version
    

    If I both WRITE and READ on Linux the binary file contains header "yas0105" and works.

    Why?

  • Invalid JSON

    Invalid JSON

    Hello,

    The following results in an invalid JSON string:

        std::vector<uint8_t>                       buf(MBytes);
        constexpr std::size_t                      opts = yas::json | yas::no_header;
        yas::mem_ostream                           os(buf.data(), buf.size());
        yas::json_oarchive<yas::mem_ostream, opts> oa(os);
        yas::mem_istream                           is(buf.data(), buf.size());
        yas::json_iarchive<yas::mem_istream, opts> ia(is);
        std::map<std::string, std::string>         map({ { "A", "B" }, { "C", "D" } });
    
        oa& YAS_OBJECT_NVP("obj", ("map", yas::init(map)));
    
    
    {"map":{{"key":"A","val":"B"},{"key":"C","val":"D"}}} <<== Invalid JSON
    

    Or should it be?

    {"map":{"A":"B","C":"D"}}
    

    Or am I missing something? I read in the docs that the serialization is not JSON compliant so that would explain this. Are you interested in adding a helper function to convert to valid json? For example:

    std::string yas::toJSON(const std::string& in)
    { 
      std::string validjson;
      ...convert by removing extra "{,},key,value,"...
      return validjson;
    }
    
  • std::wstring with utf16 serialization bug

    std::wstring with utf16 serialization bug

    Hello!

    I have a little bug serializing std::wstring objects. The bug happens when I put characters like UTF-16.

    I changed your wstring test to reproduce the problem:

    #ifndef __yas__tests__base__include__wstring_hpp
    #define __yas__tests__base__include__wstring_hpp
    
    /***************************************************************************/
    
    template<typename archive_traits>
    bool wstring_test(std::ostream &log, const char *archive_type, const char *test_name) {
    
    	std::vector<std::wstring> wcs_collection = {
    		L"A E I O U c C d D p P Á É Í Ó Ú ç Ç d D p P à è ì ò ù ã õ â ê î ô û", // pt-br
    		//L"☺ ☻ ♥ ♦ ♣ ♠ • ◘ ○ ◙ ♂ ♀ ♪ ♫ ☼ ► ◄ ↕ ‼ ¶ § ▬ ↨ ↑ ↓ → ← ∟ ↔ ▲ ▼", // symbols
    		L"đái dầm chửa hoang bí mật bầy tôi", // vn
    		L"我能吞下玻璃而不伤身体。", // zh-cn
    		L"私はガラスを食べられます。それは私を傷つけません。", // ja
    		L"मैं काँच खा सकता हूँ, मुझे उस से कोई पीडा नहीं होती.", // hi
    		L"Я могу есть стекло, оно мне не вредит.", // ru
    		L"나는 유리를 먹을 수 있어요. 그래도 아프지 않아요", // ko
    		L"I can eat glass and it doesn't hurt me.", // en
    		L"ฉันกินกระจกได้ แต่มันไม่ทำให้ฉันเจ็บ", // th
    		L"أنا قادر على أكل الزجاج و هذا لا يؤلمني", // ar
    		L"לְהַגִּיד בַּבֹּקֶר חַסְדֶּךָ וֶאֱמוּנָתְךָ בַּלֵּילוֹת", // he
    		L"Μπορώ να φάω σπασμένα γυαλιά χωρίς να πάθω τίποτα.", // el
    		L"Mohu jíst sklo, neublíží mi.", // cs
    		L"Мога да ям стъкло, то не ми вреди.", // bg
    		L"Cam yiyebilirim, bana zararı dokunmaz.", // tr
    		L"Je peux manger du verre, ça ne me fait pas de mal.", // fr
    	};
    
    	for (auto& ws : wcs_collection)
    	{
    		std::wstring wss;
    
    		typename archive_traits::oarchive oa;
    		archive_traits::ocreate(oa, archive_type);
    		oa& YAS_OBJECT_NVP("obj", ("ws", ws));
    
    		typename archive_traits::iarchive ia;
    		archive_traits::icreate(ia, oa, archive_type);
    		ia& YAS_OBJECT_NVP("obj", ("ws", wss));
    
    		if (ws != wss) {
    			YAS_TEST_REPORT(log, archive_type, test_name);
    			return false;
    		}
    	}
    
    	return true;
    }
    
    /***************************************************************************/
    
    #endif // __yas__tests__base__include__wstring_hpp
    
    cmdline: binary
    
    binary: header                   -> passed
    binary: endian                   -> passed
    binary: version                  -> passed
    binary: base64                   -> passed
    binary: fundamental              -> passed
    binary: compacted_storage_size   -> passed
    binary: enum                     -> passed
    binary: auto_array               -> passed
    binary: std_streams              -> passed
    binary: one_function             -> passed
    binary: split_functions          -> passed
    binary: one_method               -> passed
    binary: split_methods            -> passed
    binary: serialize                -> passed
    binary: serialization            -> passed
    binary: yas_object               -> passed
    binary: base_object              -> passed
    binary: array                    -> passed
    binary: bitset                   -> passed
    binary: buffer                   -> passed
    binary: chrono                   -> passed
    binary: complex                  -> passed
    binary: string                   -> passed
    binary: string_view              -> passed
    binary: wstring                  -> [...]yas\tests\base\include\wstring.hpp(77): archive: "binary", test: "wstring" failed!
    failed
    binary: pair                     -> passed
    binary: tuple                    -> passed
    binary: vector                   -> passed
    binary: list                     -> passed
    binary: forward_list             -> passed
    binary: deque                    -> passed
    binary: map                      -> passed
    binary: set                      -> passed
    binary: multimap                 -> passed
    binary: multiset                 -> passed
    binary: unordered_map            -> passed
    binary: unordered_set            -> passed
    binary: unordered_multimap       -> passed
    binary: unordered_multiset       -> passed
    binary: optional                 -> passed
    binary: variant                  -> passed
    binary: boost_fusion_pair        -> passed
    binary: boost_fusion_tuple       -> passed
    binary: boost_fusion_vector      -> passed
    binary: boost_fusion_list        -> passed
    binary: boost_fusion_set         -> passed
    binary: boost_fusion_map         -> passed
    binary: boost_cont_string        -> passed
    binary: boost_cont_wstring       -> passed
    binary: boost_cont_vector        -> passed
    binary: boost_cont_static_vector -> passed
    binary: boost_cont_stable_vector -> passed
    binary: boost_cont_list          -> passed
    binary: boost_cont_slist         -> passed
    binary: boost_cont_map           -> passed
    binary: boost_cont_multimap      -> passed
    binary: boost_cont_set           -> passed
    binary: boost_cont_multiset      -> passed
    binary: boost_cont_flat_map      -> passed
    binary: boost_cont_flat_multimap -> passed
    binary: boost_cont_flat_set      -> passed
    binary: boost_cont_flat_multiset -> passed
    binary: boost_cont_deque         -> passed
    binary: boost_tuple              -> passed
    binary: boost_variant            -> passed
    
    /***************************************************/
    > passed tests: 64
    > failed tests: 1
    > host endian : little
    > host bits   : 64
    > YAS version : 7.0.4
    /***************************************************/
    

    Test performed with Visual Studio 2019 - ISO C++14 Standard (/std:c++14)

    Thanks :)

  • Support serialization to and from std::vector

    Support serialization to and from std::vector

    This PR adds support for serializing to and from std::vector<char>, std::vector<int8_t> and std::vector<uint8_t>. It's very rare that people use std::shared_ptr<char> as a buffer container, instead of something standard like std::vector<char>. So supporting serialization to and from these containers means people can freely serialize to their buffers without having to do extra manual memory allocations and copies.

  • The problem on the format of save<json>(map)

    The problem on the format of save(map)

    Problem

    std::map<int, int> map{{1, 1}, {2, 2}, {3, 3}};
    std::map<std::string, int> obj{{"a", 1}, {"b", 2}, {"c", 3}};
    yas::save<yas::file | yas::json>("file", YAS_OBJECT("obj", map, obj);
    std::cout << std::ifstream{"file"}.rdbuf();
    // OUTPUT:
    // {"map":{{"key":1,"val":1},{"key":2,"val":2},{"key":3,"val":3}},"obj":{{"key":"a","val":1.0},{"key":"b","val":2.0},{"key":"c","val":3.0}}}
    //
    // Desired OUTPUT:
    // {"map":{{"key":1,"val":1},{"key":2,"val":2},{"key":3,"val":3}},"obj":{"a":"1","b":2,"c",3}
    

    So it means to specialized for map (and also other map). Is there a available option to get it?

  • Question : compile time check that type is serialisable

    Question : compile time check that type is serialisable

    Is it possible to have a compile time check that a type is yas-serialisable? To be specific, I am looking to do the following:

    template<typename Object, typename std::enable_if<YAS_SERIALISABLE<Object>::value>::type = 0>
    yas::shared_buffer serialise_yas(const Object& obj)
    {
    return yas::save<yas::mem | yas::binary>(obj);
    }
    
    template<typename Object, typename std::enable_if<!YAS_SERIALISABLE<Object>::value>::type = 0>
    yas::shared_buffer serialise_yas(const Object& obj)
    {
    yas::shared_buffer buf;
    printf("%s not yas-serialisable\n", typeid(Object).name());
    return buf;
    }
    
  • How to cross compile for windows with mingw?

    How to cross compile for windows with mingw?

    I'm using your yas-base-test test case and tried to compile for windows on linux using MinGW but got lot of issues.

    The first one is boost not found (it works fine when I compiled for linux but not for windows).

    yas/tests/base/../../include/yas/object.hpp:146:13: fatal error: boost/version.hpp: No such file or directory
     #   include <boost/version.hpp>
    

    I just add these lines:

    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
        # Using find package to get boost headers
        find_package(Boost REQUIRED)
        include_directories(${Boost_INCLUDE_DIRS})
    

    And now come with lot of errors (18 557 lines) Some of these:

    In file included from /usr/share/mingw-w64/include/crtdefs.h:10,
                     from /usr/share/mingw-w64/include/stddef.h:7,
                     from /usr/lib/gcc/x86_64-w64-mingw32/8.3-win32/include/stddef.h:1,
                     from /usr/include/string.h:33,
                     from /usr/lib/gcc/x86_64-w64-mingw32/8.3-win32/include/c++/cstring:42,
                     from /tmp/yas/tests/base/../../include/yas/buffers.hpp:41,
                     from /tmp/yas/tests/base/../../include/yas/mem_streams.hpp:43,
                     from /tmp/yas/tests/base/main.cpp:42:
    /usr/share/mingw-w64/include/corecrt.h:80:44: error: conflicting declaration ‘typedef long long unsigned int uintptr_t’
     __MINGW_EXTENSION typedef unsigned __int64 uintptr_t;
                                                ^~~~~~~~~
    In file included from /usr/lib/gcc/x86_64-w64-mingw32/8.3-win32/include/c++/cstdint:41,
                     from /tmp/yas/tests/base/../../include/yas/detail/type_traits/type_traits.hpp:44,
                     from /tmp/yas/tests/base/../../include/yas/mem_streams.hpp:42,
                     from /tmp/yas/tests/base/main.cpp:42:
    /usr/include/stdint.h:90:27: note: previous declaration as ‘typedef long unsigned int uintptr_t’
     typedef unsigned long int uintptr_t;
                               ^~~~~~~~~
    In file included from /usr/include/stdint.h:27,
                     from /usr/lib/gcc/x86_64-w64-mingw32/8.3-win32/include/c++/cstdint:41,
                     from /tmp/yas/tests/base/../../include/yas/detail/type_traits/type_traits.hpp:44,
                     from /tmp/yas/tests/base/../../include/yas/mem_streams.hpp:42,
                     from /tmp/yas/tests/base/main.cpp:42:
    /usr/share/mingw-w64/include/corecrt.h:128:35: error: conflicting declaration ‘typedef long long int __time_t’
     __MINGW_EXTENSION typedef __int64 __time64_t;
                                       ^~~~~~~~~~
    /usr/include/bits/types.h:160:26: note: previous declaration as ‘typedef long int __time_t’
     __STD_TYPE __TIME_T_TYPE __time_t; /* Seconds since the Epoch.  */
    

    Is is due to the import of boost I made?

    Simple cmake toolchain I use:

    # the name of the target operating system
    set(CMAKE_SYSTEM_NAME Windows)
    set(CMAKE_EXE_LINKER_FLAGS -static-libstdc++\ -static-libgcc\ -static)
    
    # Which compilers to use for C and C++
    set(CMAKE_C_COMPILER /usr/bin/x86_64-w64-mingw32-gcc)
    set(CMAKE_CXX_COMPILER /usr/bin/x86_64-w64-mingw32-g++)
    set(CMAKE_RC_COMPILER /usr/bin/x86_64-w64-mingw32-windres)
    
  • MSVC compile errors with /Zc:__cplusplus

    MSVC compile errors with /Zc:__cplusplus

    I'm using Visual Studio 2019. When I add option /Zc:__cplusplus (fixes __cplusplus macro value) it refuses to compile. I get strange errors like yas\include\yas\types\std\pair.hpp(63,1): error C2975: '_Val': invalid template argument for 'std::integral_constant', expected compile-time constant expression

    I did a quick test with file examples/one_memfn/main.cpp

    This compiles: cl main.cpp /I"../../include" /EHsc /std:c++17 /permissive-

    And this does not: cl main.cpp /I"../../include" /EHsc /std:c++17 /permissive- /Zc:__cplusplus

    This probably has something to do with fnv1a function in include\yas\detail\tools\fnv1a.hpp . If you switch to the code for __cplusplus < 201402L yas compiles just fine.

  • The binary_istream checks the stored size on read

    The binary_istream checks the stored size on read

    If in the compacted mode, the serialized size is greater than the size of the datatype to store the value into, a exception is thrown.

    Hi!

    As in my previous commit I used the speed test to ensure the changes don't degrade the performance.

  • OSX catalina GCC macports

    OSX catalina GCC macports

    Having this issue:

    export CC=/opt/local/bin/gcc-mp-9; export CXX=/opt/local/bin/g++-mp-9

    boost is in /opt/local

    I added this to CMakeKists.txt

    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra") include_directories("/opt/local/include") link_directories("/opt/local/lib") add_definitions( -DBOOST_ERROR_CODE_HEADER_ONLY -DBOOST_CHRONO_HEADER_ONLY -DYAS_SERIALIZE_BOOST_TYPES -DYAS_OBJECT_MAX_MEMBERS=50 )

    
    -- The C compiler identification is GNU 9.2.0
    -- The CXX compiler identification is GNU 9.2.0
    -- Checking whether C compiler has -isysroot
    -- Checking whether C compiler has -isysroot - yes
    -- Checking whether C compiler supports OSX deployment target flag
    -- Checking whether C compiler supports OSX deployment target flag - yes
    -- Check for working C compiler: /opt/local/bin/gcc-mp-9
    -- Check for working C compiler: /opt/local/bin/gcc-mp-9 -- works
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Detecting C compile features
    -- Detecting C compile features - done
    -- Checking whether CXX compiler has -isysroot
    -- Checking whether CXX compiler has -isysroot - yes
    -- Checking whether CXX compiler supports OSX deployment target flag
    -- Checking whether CXX compiler supports OSX deployment target flag - yes
    -- Check for working CXX compiler: /opt/local/bin/g++-mp-9
    -- Check for working CXX compiler: /opt/local/bin/g++-mp-9 -- works
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Detecting CXX compile features
    -- Detecting CXX compile features - done
    -- Configuring done
    -- Generating done
    
    
  • base64.hpp compile error on big endian (powerpc)

    base64.hpp compile error on big endian (powerpc)

    I get this error when compiling on powerpc:

    /usr/include/yas/detail/tools/base64.hpp:578:29: error: 'src' was not declared in this scope
    

    And then dozens of similar errors:

    /usr/include/yas/detail/tools/base64.hpp:580:10: error: 'i' was not declared in this scope
    
    /usr/include/yas/detail/tools/base64.hpp:584:52: error: there are no arguments to 'YAS_THROW_BASE64_ERROR' that depend on a template parameter, so a declaration of 'YAS_THROW_BASE64_ERROR' must be available
    

    (And so on.)

    Seems like big endian hasn't compiled in a while (ever?).

Yet another JSON/YAML/BSON serialization library for C++.
Yet another JSON/YAML/BSON serialization library for C++.

ThorsSerializer Support for Json Yaml Bson NEW Benchmark Results Conformance mac linux Performance max linux For details see: JsonBenchmark Yet anothe

Jun 15, 2022
Your binary serialization library

Bitsery Header only C++ binary serialization library. It is designed around the networking requirements for real-time data delivery, especially for ga

Jun 15, 2022
Jun 16, 2022
Cap'n Proto serialization/RPC system - core tools and C++ library
Cap'n Proto serialization/RPC system - core tools and C++ library

Cap'n Proto is an insanely fast data interchange format and capability-based RPC system. Think JSON, except binary. Or think Protocol Buffers, except

Jun 23, 2022
A C++11 library for serialization
A C++11 library for serialization

cereal - A C++11 library for serialization cereal is a header-only C++11 serialization library. cereal takes arbitrary data types and reversibly turns

Jun 23, 2022
Fast Binary Encoding is ultra fast and universal serialization solution for C++, C#, Go, Java, JavaScript, Kotlin, Python, Ruby, Swift

Fast Binary Encoding (FBE) Fast Binary Encoding allows to describe any domain models, business objects, complex data structures, client/server request

Jun 16, 2022
FlatBuffers: Memory Efficient Serialization Library

FlatBuffers FlatBuffers is a cross platform serialization library architected for maximum memory efficiency. It allows you to directly access serializ

Jun 20, 2022
Binary Serialization

Binn Binn is a binary data serialization format designed to be compact, fast and easy to use. Performance The elements are stored with their sizes to

Jun 13, 2022
An implementation of the MessagePack serialization format in C / msgpack.org[C]

CMP CMP is a C implementation of the MessagePack serialization format. It currently implements version 5 of the MessagePack Spec. CMP's goal is to be

May 27, 2022
MPack - A C encoder/decoder for the MessagePack serialization format / msgpack.org[C]

Introduction MPack is a C implementation of an encoder and decoder for the MessagePack serialization format. It is: Simple and easy to use Secure agai

May 24, 2022
Simple C++ 20 Serialization Library that works out of the box with aggregate types!

BinaryLove3 Simple C++ 20 Serialization Library that works out of the box with aggregate types! Requirements BinaryLove3 is a c++20 only library.

Dec 23, 2021
Zmeya is a header-only C++11 binary serialization library designed for games and performance-critical applications

Zmeya Zmeya is a header-only C++11 binary serialization library designed for games and performance-critical applications. Zmeya is not even a serializ

Jun 6, 2022
CppSerdes is a serialization/deserialization library designed with embedded systems in mind
CppSerdes is a serialization/deserialization library designed with embedded systems in mind

A C++ serialization/deserialization library designed with embedded systems in mind

Jun 3, 2022
Serialization framework for Unreal Engine Property System that just works!

DataConfig Serialization framework for Unreal Engine Property System that just works! Unreal Engine features a powerful Property System which implemen

Jun 12, 2022
Header-only library for automatic (de)serialization of C++ types to/from JSON.

fuser 1-file header-only library for automatic (de)serialization of C++ types to/from JSON. how it works The library has a predefined set of (de)seria

Jun 4, 2022
C++17 library for all your binary de-/serialization needs

blobify blobify is a header-only C++17 library to handle binary de-/serialization in your project. Given a user-defined C++ struct, blobify can encode

May 29, 2022
universal serialization engine

A Universal Serialization Engine Based on compile-time Reflection iguana is a modern, universal and easy-to-use serialization engine developed in c++1

Jun 20, 2022
Cista is a simple, high-performance, zero-copy C++ serialization & reflection library.

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

Jun 11, 2022
A lightweight C++20 serialization framework

zpp::bits A modern C++20 binary serialization library, with just one header file. This library is a successor to zpp::serializer. The library tries to

Jun 9, 2022