Scarfski/bitsery
1
0
Fork 0
mirror of https://github.com/fraillt/bitsery.git synced 2026-06-08 08:13:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

renamed flexible to brief_syntax

Browse Source
This commit is contained in:
Mindaugas Vinkelis
2019-07-04 14:17:36 +03:00
committed by Mindaugas Vinkelis
parent ff40222124
commit f35ae3f4dc
29 changed files with 240 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
doc/README.md
View File

@@ -4,7 +4,7 @@ Once you're familiar with the library consider the following reference material.
Library design:
* `fundamental types`
* `valueNb instead of value`
* `flexible syntax`
* `brief syntax`
* `serializer/deserializer functions overloads`
* `extending library functionality`
* `errors handling`
@@ -15,9 +15,8 @@ Library design:
Core Serializer/Deserializer functions (alphabetical order):
* `operator()` (4.6.1) (when flexible syntax is enabled)
* `operator()` (4.6.1) (when brief syntax is enabled)
* `adapter` (5.0.0)
* `archive` (4.0.0) (when flexible syntax is enabled)
* `boolValue` (4.0.0)
* `context<T>` (4.1.0)
* `contextOrNull<T>` (4.2.0)

4
doc/design/README.md
View File

@@ -34,8 +34,8 @@ Now let's review features in more detail.
* **Cross-platform compatible.** if same code compiles on Android, PS3 console, and your PC either x64 or x86 architecture, you are 100% sure it works.
To achieve this, bitsery specifically defines size of underlying data, hence syntax is *value\<2\>* (alias function *value2b*) instead or *value*, or *container2b* for element type of 16bits, eg int16_t.
Bitsery also applies endianness transformation if necessary.
* **Flexible syntax.** If you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b*, you can use flexible syntax.
Just include <bitsery/flexible.h> and can write like in [cereal](http://uscilab.github.io/cereal/).
* **Brief syntax.** If you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b*, you can use brief syntax.
Just include <bitsery/brief_syntax.h> and can write like in [cereal](http://uscilab.github.io/cereal/).
But do it on your own risk, and static assert using *assertFundamentalTypeSizes* function if you're planing to use it across multiple platforms.
* **Optimized for speed and space.** library itself doesn't do any allocations (except if you use backward/forward compatibility) so data writing/reading is fast as memcpy to/from your buffer.
It also doesn't serialize any type information, all information needed is written in your code!

2
doc/tutorial/hello_world.md
View File

@@ -58,7 +58,7 @@ void serialize(S& s, MyStruct& o) {
**bitsery** also allows to define serialize function in side your class, and can also serialize private class members, just make *friend bitsery::Access;*
**bitsery** supports two ways how to describe your serialization flow: *verbose syntax* (as in example) or *flexible syntax*, similar to *cereal* library, just include `<bitsery/flexible.h>` to use it.
**bitsery** supports two ways how to describe your serialization flow: *verbose syntax* (as in example) or *brief syntax*, similar to *cereal* library, just include `<bitsery/brief_syntax.h>` to use it.
This example we choosed probably unfamiliar verbose syntax, so lets explain core functionality that you'll use all the time:
* **s.value4b(o.i);** serialize fundamental types (ints, floats, enums) value**4b** means, that data type is 4 bytes. If you use same code on different machines, if it compiles it means it is compatible.