Statistics
| Revision:

root / tmp / org.txm.statsengine.r.core.win32 / res / win32 / library / BH / include / boost / archive / basic_archive.hpp @ 2486

History | View | Annotate | Download (9 kB)

1
#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
2
#define BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
3

    
4
// MS compatible compilers support #pragma once
5
#if defined(_MSC_VER)
6
# pragma once
7
#endif
8

    
9
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
10
// basic_archive.hpp:
11

    
12
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . 
13
// Use, modification and distribution is subject to the Boost Software
14
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
15
// http://www.boost.org/LICENSE_1_0.txt)
16

    
17
//  See http://www.boost.org for updates, documentation, and revision history.
18
#include <cstring> // count
19
#include <boost/assert.hpp>
20
#include <boost/config.hpp>
21
#include <boost/cstdint.hpp> // size_t
22
#include <boost/noncopyable.hpp>
23
#include <boost/integer_traits.hpp>
24

    
25
#include <boost/archive/detail/auto_link_archive.hpp>
26
#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
27

    
28
namespace boost {
29
namespace archive {
30

    
31
#if defined(_MSC_VER)
32
#pragma warning( push )
33
#pragma warning( disable : 4244 4267 )
34
#endif
35

    
36
/* NOTE : Warning  : Warning : Warning : Warning : Warning
37
 * Don't ever changes this.  If you do, they previously created
38
 * binary archives won't be readable !!!
39
 */
40
class library_version_type {
41
private:
42
    typedef uint_least16_t base_type;
43
    base_type t;
44
public:
45
    library_version_type(): t(0) {};
46
    explicit library_version_type(const unsigned int & t_) : t(t_){
47
        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
48
    }
49
    library_version_type(const library_version_type & t_) : 
50
        t(t_.t)
51
    {}
52
    library_version_type & operator=(const library_version_type & rhs){
53
        t = rhs.t; 
54
        return *this;
55
    }
56
    // used for text output
57
    operator base_type () const {
58
        return t;
59
    }                
60
    // used for text input
61
    operator base_type & (){
62
        return t;
63
    }                
64
    bool operator==(const library_version_type & rhs) const {
65
        return t == rhs.t;
66
    } 
67
    bool operator<(const library_version_type & rhs) const {
68
        return t < rhs.t;
69
    }   
70
};
71

    
72
BOOST_ARCHIVE_DECL library_version_type
73
BOOST_ARCHIVE_VERSION();
74

    
75
class version_type {
76
private:
77
    typedef uint_least32_t base_type;
78
    base_type t;
79
public:
80
    // should be private - but MPI fails if it's not!!!
81
    version_type(): t(0) {};
82
    explicit version_type(const unsigned int & t_) : t(t_){
83
        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
84
    }
85
    version_type(const version_type & t_) : 
86
        t(t_.t)
87
    {}
88
    version_type & operator=(const version_type & rhs){
89
        t = rhs.t; 
90
        return *this;
91
    }
92
    // used for text output
93
    operator base_type () const {
94
        return t;
95
    }                
96
    // used for text intput
97
    operator base_type  & (){
98
        return t;
99
    }                
100
    bool operator==(const version_type & rhs) const {
101
        return t == rhs.t;
102
    } 
103
    bool operator<(const version_type & rhs) const {
104
        return t < rhs.t;
105
    }   
106
};
107

    
108
class class_id_type {
109
private:
110
    typedef int_least16_t base_type;
111
    base_type t;
112
public:
113
    // should be private - but then can't use BOOST_STRONG_TYPE below
114
    class_id_type() : t(0) {};
115
    explicit class_id_type(const int t_) : t(t_){
116
        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
117
    }
118
    explicit class_id_type(const std::size_t t_) : t(t_){
119
 //       BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
120
    }
121
    class_id_type(const class_id_type & t_) : 
122
        t(t_.t)
123
    {}
124
    class_id_type & operator=(const class_id_type & rhs){
125
        t = rhs.t; 
126
        return *this;
127
    }
128

    
129
    // used for text output
130
    operator int () const {
131
        return t;
132
    }                
133
    // used for text input
134
    operator int_least16_t &() {
135
        return t;
136
    }                
137
    bool operator==(const class_id_type & rhs) const {
138
        return t == rhs.t;
139
    } 
140
    bool operator<(const class_id_type & rhs) const {
141
        return t < rhs.t;
142
    }   
143
};
144

    
145
#define NULL_POINTER_TAG boost::archive::class_id_type(-1)
146

    
147
class object_id_type {
148
private:
149
    typedef uint_least32_t base_type;
150
    base_type t;
151
public:
152
    object_id_type(): t(0) {};
153
    // note: presumes that size_t >= unsigned int.
154
    explicit object_id_type(const std::size_t & t_) : t(t_){
155
        BOOST_ASSERT(t_ <= boost::integer_traits<base_type>::const_max);
156
    }
157
    object_id_type(const object_id_type & t_) : 
158
        t(t_.t)
159
    {}
160
    object_id_type & operator=(const object_id_type & rhs){
161
        t = rhs.t; 
162
        return *this;
163
    }
164
    // used for text output
165
    operator uint_least32_t () const {
166
        return t;
167
    }                
168
    // used for text input
169
    operator uint_least32_t & () {
170
        return t;
171
    }                
172
    bool operator==(const object_id_type & rhs) const {
173
        return t == rhs.t;
174
    } 
175
    bool operator<(const object_id_type & rhs) const {
176
        return t < rhs.t;
177
    }   
178
};
179

    
180
#if defined(_MSC_VER)
181
#pragma warning( pop )
182
#endif
183

    
184
struct tracking_type {
185
    bool t;
186
    explicit tracking_type(const bool t_ = false)
187
        : t(t_)
188
    {};
189
    tracking_type(const tracking_type & t_)
190
        : t(t_.t)
191
    {}
192
    operator bool () const {
193
        return t;
194
    };
195
    operator bool & () {
196
        return t;
197
    };
198
    tracking_type & operator=(const bool t_){
199
        t = t_;
200
        return *this;
201
    }
202
    bool operator==(const tracking_type & rhs) const {
203
        return t == rhs.t;
204
    }
205
    bool operator==(const bool & rhs) const {
206
        return t == rhs;
207
    }
208
    tracking_type & operator=(const tracking_type & rhs){
209
        t = rhs.t;
210
        return *this;
211
    }
212
};
213

    
214
struct class_name_type : 
215
    private boost::noncopyable 
216
{
217
    char *t;
218
    operator const char * & () const {
219
        return const_cast<const char * &>(t);
220
    }
221
    operator char * () {
222
        return t;
223
    }
224
    std::size_t size() const {
225
        return std::strlen(t);
226
    }
227
    explicit class_name_type(const char *key_) 
228
    : t(const_cast<char *>(key_)){}
229
    explicit class_name_type(char *key_) 
230
    : t(key_){}
231
    class_name_type & operator=(const class_name_type & rhs){
232
        t = rhs.t;
233
        return *this;
234
    }
235
};
236

    
237
enum archive_flags {
238
    no_header = 1,  // suppress archive header info
239
    no_codecvt = 2,  // suppress alteration of codecvt facet
240
    no_xml_tag_checking = 4,   // suppress checking of xml tags
241
    no_tracking = 8,           // suppress ALL tracking
242
    flags_last = 8
243
};
244

    
245
BOOST_ARCHIVE_DECL const char *
246
BOOST_ARCHIVE_SIGNATURE();
247

    
248
/* NOTE : Warning  : Warning : Warning : Warning : Warning
249
 * If any of these are changed to different sized types, 
250
 * binary_iarchive won't be able to read older archives
251
 * unless you rev the library version and include conditional
252
 * code based on the library version.  There is nothing
253
 * inherently wrong in doing this - but you have to be super
254
 * careful because it's easy to get wrong and start breaking
255
 * old archives !!!
256
 */
257

    
258
#define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
259
    class D : public T {                           \
260
    public:                                        \
261
        explicit D(const T tt) : T(tt){}           \
262
    };                                             \
263
/**/
264

    
265
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_reference_type)
266
BOOST_ARCHIVE_STRONG_TYPEDEF(class_id_type, class_id_optional_type)
267
BOOST_ARCHIVE_STRONG_TYPEDEF(object_id_type, object_reference_type)
268

    
269
}// namespace archive
270
}// namespace boost
271

    
272
#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
273

    
274
#include <boost/serialization/level.hpp>
275

    
276
// set implementation level to primitive for all types
277
// used internally by the serialization library
278

    
279
BOOST_CLASS_IMPLEMENTATION(boost::archive::library_version_type, primitive_type)
280
BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
281
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
282
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
283
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
284
BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
285
BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
286
BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
287
BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
288

    
289
#include <boost/serialization/is_bitwise_serializable.hpp>
290

    
291
// set types used internally by the serialization library 
292
// to be bitwise serializable
293

    
294
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::library_version_type)
295
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::version_type)
296
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_type)
297
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_reference_type)
298
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_id_optional_type)
299
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::class_name_type)
300
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_id_type)
301
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::object_reference_type)
302
BOOST_IS_BITWISE_SERIALIZABLE(boost::archive::tracking_type)
303

    
304
#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP