1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
[/
Copyright 2023 Peter Dimov
Distributed under the Boost Software License, Version 1.0.
https://boost.org/LICENSE_1_0.txt
]
[section:serialization serialization]
[simplesect Authors]
* Peter Dimov
[endsimplesect]
[section Header <boost/core/serialization.hpp>]
The header `<boost/core/serialization.hpp>` implements primitives
that are necessary to implement Boost.Serialization support without
including a Boost.Serialization header and thereby making a library
dependent on Boost.Serialization.
[section Synopsis]
``
#include <boost/core/nvp.hpp>
namespace boost
{
namespace serialization
{
// forward declarations
template<class T> struct version;
class access;
// core_version_type
struct core_version_type;
} // namespace serialization
namespace core
{
// nvp
using serialization::nvp;
using serialization::make_nvp;
// split_free
template<class Ar, class T> void split_free( Ar& ar, T& t, unsigned int v );
// split_member
template<class Ar, class T> void split_member( Ar& ar, T& t, unsigned int v );
// load_construct_data_adl
template<class Ar, class T> void load_construct_data_adl( Ar& ar, T* t, unsigned int v );
// save_construct_data_adl
template<class Ar, class T> void save_construct_data_adl( Ar& ar, T const* t, unsigned int v );
} // namespace core
} // namespace boost
``
[endsect]
[section `core_version_type`]
``
struct core_version_type
{
unsigned int version_;
core_version_type( unsigned int version ): version_( version ) {}
operator unsigned int () const { return version_; }
};
``
`core_version_type` is a Core reimplementation of
`boost::serialization::version_type`, needed to call ADL serialization
primitives such as, for example, `load_construct_data` below.
It's defined in the `serialization` namespace instead of the `core`
namespace because its only purpose is to add `boost::serialization` to
the list of the associated namespaces of the corresponding call.
[endsect]
[section `split_free`]
`template<class Ar, class T> inline void split_free( Ar& ar, T& t, unsigned int v );`
`boost::core::split_free` is a Core reimplementation of
`boost::serialization::split_free`.
* *Effects:*
* If `Ar::is_saving::value` is `true`, calls `save( ar, t, core_version_type( v ) )`;
* Otherwise, calls `load( ar, t, core_version_type( v ) )`.
[endsect]
[section `split_member`]
`template<class Ar, class T> void split_member( Ar& ar, T& t, unsigned int v );`
`boost::core::split_member` is a Core reimplementation of
`boost::serialization::split_member`.
* *Effects:*
* If `Ar::is_saving::value` is `true`, calls `t.save( ar, v )`;
* Otherwise, calls `t.load( ar, v )`.
[endsect]
[section `load_construct_data_adl`]
`template<class Ar, class T> void load_construct_data_adl( Ar& ar, T* t, unsigned int v );`
`boost::core::load_construct_data_adl` is a Core reimplementation of
`boost::serialization::load_construct_data_adl`.
* *Effects:* `load_construct_data( ar, t, serialization::core_version_type( v ) );`.
[endsect]
[section `save_construct_data_adl`]
`template<class Ar, class T> void save_construct_data_adl( Ar& ar, T const* t, unsigned int v );`
`boost::core::save_construct_data_adl` is a Core reimplementation of
`boost::serialization::save_construct_data_adl`.
* *Effects:* `save_construct_data( ar, t, serialization::core_version_type( v ) );`.
[endsect]
[endsect]
[endsect]
|
