1 #ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
2 #define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_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_binary_iarchive.hpp
11 //
12 // archives stored as native binary - this should be the fastest way
13 // to archive the state of a group of obects.  It makes no attempt to
14 // convert to any canonical form.
15 
16 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
17 // ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
18 
19 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
20 // Use, modification and distribution is subject to the Boost Software
21 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
22 // http://www.boost.org/LICENSE_1_0.txt)
23 
24 //  See http://www.boost.org for updates, documentation, and revision history.
25 
26 #include <boost/config.hpp>
27 #include <boost/detail/workaround.hpp>
28 
29 #include <boost/archive/basic_archive.hpp>
30 #include <boost/archive/detail/common_iarchive.hpp>
31 #include <boost/serialization/collection_size_type.hpp>
32 #include <boost/serialization/string.hpp>
33 #include <boost/serialization/item_version_type.hpp>
34 #include <boost/integer_traits.hpp>
35 
36 #ifdef BOOST_MSVC
37 #  pragma warning(push)
38 #  pragma warning(disable : 4511 4512)
39 #endif
40 
41 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
42 
43 namespace boost {
44 namespace archive {
45 
46 namespace detail {
47     template<class Archive> class interface_iarchive;
48 } // namespace detail
49 
50 /////////////////////////////////////////////////////////////////////////
51 // class basic_binary_iarchive - read serialized objects from a input binary stream
52 template<class Archive>
53 class BOOST_SYMBOL_VISIBLE basic_binary_iarchive :
54     public detail::common_iarchive<Archive>
55 {
56 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
57 public:
58 #else
59 protected:
60     #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
61         // for some inexplicable reason insertion of "class" generates compile erro
62         // on msvc 7.1
63         friend detail::interface_iarchive<Archive>;
64     #else
65         friend class detail::interface_iarchive<Archive>;
66     #endif
67 #endif
68     // intermediate level to support override of operators
69     // fot templates in the absence of partial function
70     // template ordering. If we get here pass to base class
71     // note extra nonsense to sneak it pass the borland compiers
72     typedef detail::common_iarchive<Archive> detail_common_iarchive;
73     template<class T>
load_override(T & t)74     void load_override(T & t){
75       this->detail_common_iarchive::load_override(t);
76     }
77 
78     // include these to trap a change in binary format which
79     // isn't specifically handled
80     // upto 32K classes
81     BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
82     BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
83     // upto 2G objects
84     BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
85     BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
86 
87     // binary files don't include the optional information
load_override(class_id_optional_type &)88     void load_override(class_id_optional_type & /* t */){}
89 
load_override(tracking_type & t,int)90     void load_override(tracking_type & t, int /*version*/){
91         library_version_type lvt = this->get_library_version();
92         if(boost::archive::library_version_type(6) < lvt){
93             int_least8_t x=0;
94             * this->This() >> x;
95             t = boost::archive::tracking_type(x);
96         }
97         else{
98             bool x=0;
99             * this->This() >> x;
100             t = boost::archive::tracking_type(x);
101         }
102     }
load_override(class_id_type & t)103     void load_override(class_id_type & t){
104         library_version_type lvt = this->get_library_version();
105         if(boost::archive::library_version_type(7) < lvt){
106             this->detail_common_iarchive::load_override(t);
107         }
108         else
109         if(boost::archive::library_version_type(6) < lvt){
110             int_least16_t x=0;
111             * this->This() >> x;
112             t = boost::archive::class_id_type(x);
113         }
114         else{
115             int x=0;
116             * this->This() >> x;
117             t = boost::archive::class_id_type(x);
118         }
119     }
load_override(class_id_reference_type & t)120     void load_override(class_id_reference_type & t){
121         load_override(static_cast<class_id_type &>(t));
122     }
123 
load_override(version_type & t)124     void load_override(version_type & t){
125         library_version_type lvt = this->get_library_version();
126         if(boost::archive::library_version_type(7) < lvt){
127             this->detail_common_iarchive::load_override(t);
128         }
129         else
130         if(boost::archive::library_version_type(6) < lvt){
131             uint_least8_t x=0;
132             * this->This() >> x;
133             t = boost::archive::version_type(x);
134         }
135         else
136         if(boost::archive::library_version_type(5) < lvt){
137             uint_least16_t x=0;
138             * this->This() >> x;
139             t = boost::archive::version_type(x);
140         }
141         else
142         if(boost::archive::library_version_type(2) < lvt){
143             // upto 255 versions
144             unsigned char x=0;
145             * this->This() >> x;
146             t = version_type(x);
147         }
148         else{
149             unsigned int x=0;
150             * this->This() >> x;
151             t = boost::archive::version_type(x);
152         }
153     }
154 
load_override(boost::serialization::item_version_type & t)155     void load_override(boost::serialization::item_version_type & t){
156         library_version_type lvt = this->get_library_version();
157 //        if(boost::archive::library_version_type(7) < lvt){
158         if(boost::archive::library_version_type(6) < lvt){
159             this->detail_common_iarchive::load_override(t);
160         }
161         else
162         if(boost::archive::library_version_type(6) < lvt){
163             uint_least16_t x=0;
164             * this->This() >> x;
165             t = boost::serialization::item_version_type(x);
166         }
167         else{
168             unsigned int x=0;
169             * this->This() >> x;
170             t = boost::serialization::item_version_type(x);
171         }
172     }
173 
load_override(serialization::collection_size_type & t)174     void load_override(serialization::collection_size_type & t){
175         if(boost::archive::library_version_type(5) < this->get_library_version()){
176             this->detail_common_iarchive::load_override(t);
177         }
178         else{
179             unsigned int x=0;
180             * this->This() >> x;
181             t = serialization::collection_size_type(x);
182         }
183     }
184 
185     BOOST_ARCHIVE_OR_WARCHIVE_DECL void
186     load_override(class_name_type & t);
187     BOOST_ARCHIVE_OR_WARCHIVE_DECL void
188     init();
189 
basic_binary_iarchive(unsigned int flags)190     basic_binary_iarchive(unsigned int flags) :
191         detail::common_iarchive<Archive>(flags)
192     {}
193 };
194 
195 } // namespace archive
196 } // namespace boost
197 
198 #ifdef BOOST_MSVC
199 #pragma warning(pop)
200 #endif
201 
202 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
203 
204 #endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
205