1 #ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
2 #define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_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_oarchive.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 
19 // archives stored as native binary - this should be the fastest way
20 // to archive the state of a group of obects.  It makes no attempt to
21 // convert to any canonical form.
22 
23 // IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
24 // ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
25 
26 #include <boost/assert.hpp>
27 #include <boost/config.hpp>
28 #include <boost/detail/workaround.hpp>
29 
30 #include <boost/integer.hpp>
31 #include <boost/integer_traits.hpp>
32 
33 #include <boost/archive/detail/common_oarchive.hpp>
34 #include <boost/serialization/string.hpp>
35 #include <boost/serialization/collection_size_type.hpp>
36 #include <boost/serialization/item_version_type.hpp>
37 
38 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
39 
40 #ifdef BOOST_MSVC
41 #  pragma warning(push)
42 #  pragma warning(disable : 4511 4512)
43 #endif
44 
45 namespace boost {
46 namespace archive {
47 
48 namespace detail {
49     template<class Archive> class interface_oarchive;
50 } // namespace detail
51 
52 //////////////////////////////////////////////////////////////////////
53 // class basic_binary_oarchive - write serialized objects to a binary output stream
54 // note: this archive has no pretensions to portability.  Archive format
55 // may vary across machine architectures and compilers.  About the only
56 // guarentee is that an archive created with this code will be readable
57 // by a program built with the same tools for the same machne.  This class
58 // does have the virtue of buiding the smalles archive in the minimum amount
59 // of time.  So under some circumstances it may be he right choice.
60 template<class Archive>
61 class BOOST_SYMBOL_VISIBLE basic_binary_oarchive :
62     public detail::common_oarchive<Archive>
63 {
64 #ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
65 public:
66 #else
67 protected:
68     #if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
69         // for some inexplicable reason insertion of "class" generates compile erro
70         // on msvc 7.1
71         friend detail::interface_oarchive<Archive>;
72     #else
73         friend class detail::interface_oarchive<Archive>;
74     #endif
75 #endif
76     // any datatype not specifed below will be handled by base class
77     typedef detail::common_oarchive<Archive> detail_common_oarchive;
78     template<class T>
save_override(const T & t)79     void save_override(const T & t){
80       this->detail_common_oarchive::save_override(t);
81     }
82 
83     // include these to trap a change in binary format which
84     // isn't specifically handled
85     BOOST_STATIC_ASSERT(sizeof(tracking_type) == sizeof(bool));
86     // upto 32K classes
87     BOOST_STATIC_ASSERT(sizeof(class_id_type) == sizeof(int_least16_t));
88     BOOST_STATIC_ASSERT(sizeof(class_id_reference_type) == sizeof(int_least16_t));
89     // upto 2G objects
90     BOOST_STATIC_ASSERT(sizeof(object_id_type) == sizeof(uint_least32_t));
91     BOOST_STATIC_ASSERT(sizeof(object_reference_type) == sizeof(uint_least32_t));
92 
93     // binary files don't include the optional information
save_override(const class_id_optional_type &)94     void save_override(const class_id_optional_type & /* t */){}
95 
96     // enable this if we decide to support generation of previous versions
97     #if 0
98     void save_override(const boost::archive::version_type & t){
99         library_version_type lvt = this->get_library_version();
100         if(boost::archive::library_version_type(7) < lvt){
101             this->detail_common_oarchive::save_override(t);
102         }
103         else
104         if(boost::archive::library_version_type(6) < lvt){
105             const boost::uint_least16_t x = t;
106             * this->This() << x;
107         }
108         else{
109             const unsigned int x = t;
110             * this->This() << x;
111         }
112     }
113     void save_override(const boost::serialization::item_version_type & t){
114         library_version_type lvt = this->get_library_version();
115         if(boost::archive::library_version_type(7) < lvt){
116             this->detail_common_oarchive::save_override(t);
117         }
118         else
119         if(boost::archive::library_version_type(6) < lvt){
120             const boost::uint_least16_t x = t;
121             * this->This() << x;
122         }
123         else{
124             const unsigned int x = t;
125             * this->This() << x;
126         }
127     }
128 
129     void save_override(class_id_type & t){
130         library_version_type lvt = this->get_library_version();
131         if(boost::archive::library_version_type(7) < lvt){
132             this->detail_common_oarchive::save_override(t);
133         }
134         else
135         if(boost::archive::library_version_type(6) < lvt){
136             const boost::int_least16_t x = t;
137             * this->This() << x;
138         }
139         else{
140             const int x = t;
141             * this->This() << x;
142         }
143     }
144     void save_override(class_id_reference_type & t){
145         save_override(static_cast<class_id_type &>(t));
146     }
147 
148     #endif
149 
150     // explicitly convert to char * to avoid compile ambiguities
save_override(const class_name_type & t)151     void save_override(const class_name_type & t){
152         const std::string s(t);
153         * this->This() << s;
154     }
155 
156     #if 0
157     void save_override(const serialization::collection_size_type & t){
158         if (get_library_version() < boost::archive::library_version_type(6)){
159             unsigned int x=0;
160             * this->This() >> x;
161             t = serialization::collection_size_type(x);
162         }
163         else{
164             * this->This() >> t;
165         }
166     }
167     #endif
168     BOOST_ARCHIVE_OR_WARCHIVE_DECL void
169     init();
170 
basic_binary_oarchive(unsigned int flags)171     basic_binary_oarchive(unsigned int flags) :
172         detail::common_oarchive<Archive>(flags)
173     {}
174 };
175 
176 } // namespace archive
177 } // namespace boost
178 
179 #ifdef BOOST_MSVC
180 #pragma warning(pop)
181 #endif
182 
183 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
184 
185 #endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
186