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

	class BorNode {
	public:
		map<const char, BorNode *>links;
		BorNode *fail; 
		BorNode *term;
		int out;
	};

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

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?

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

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

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.

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?

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

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)

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.

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.

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

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?).