Publishing R3
[platform/upstream/dldt.git] / inference-engine / thirdparty / clDNN / common / boost / 1.64.0 / include / boost-1_64 / boost / serialization / serialization.hpp
1 #ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
2 #define BOOST_SERIALIZATION_SERIALIZATION_HPP
3
4 // MS compatible compilers support #pragma once
5 #if defined(_MSC_VER)
6 # pragma once
7 #endif
8
9 #if defined(_MSC_VER)
10 #  pragma warning (disable : 4675) // suppress ADL warning
11 #endif
12
13 #include <boost/config.hpp>
14 #include <boost/serialization/strong_typedef.hpp>
15
16 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
17 // serialization.hpp: interface for serialization system.
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 //////////////////////////////////////////////////////////////////////
27 // public interface to serialization. 
28
29 /////////////////////////////////////////////////////////////////////////////
30 // layer 0 - intrusive verison
31 // declared and implemented for each user defined class to be serialized
32 //
33 //  template<Archive>
34 //  serialize(Archive &ar, const unsigned int file_version){
35 //      ar & base_object<base>(*this) & member1 & member2 ... ;
36 //  }
37
38 /////////////////////////////////////////////////////////////////////////////
39 // layer 1 - layer that routes member access through the access class.
40 // this is what permits us to grant access to private class member functions
41 // by specifying friend class boost::serialization::access
42
43 #include <boost/serialization/access.hpp>
44
45 /////////////////////////////////////////////////////////////////////////////
46 // layer 2 - default implementation of non-intrusive serialization.
47 //
48 // note the usage of function overloading to compensate that C++ does not
49 // currently support Partial Template Specialization for function templates 
50 // We have declared the version number as "const unsigned long".  
51 // Overriding templates for specific data types should declare the version
52 // number as "const unsigned int". Template matching will first be applied
53 // to functions with the same version types - that is the overloads.  
54 // If there is no declared function prototype that matches, the second argument
55 // will be converted to "const unsigned long" and a match will be made with 
56 // one of the default template functions below.
57
58 namespace boost {
59 namespace serialization {
60
61 BOOST_STRONG_TYPEDEF(unsigned int, version_type)
62
63 // default implementation - call the member function "serialize"
64 template<class Archive, class T>
65 inline void serialize(
66     Archive & ar, T & t, const unsigned int file_version
67 ){
68     access::serialize(ar, t, static_cast<unsigned int>(file_version));
69 }
70
71 // save data required for construction
72 template<class Archive, class T>
73 inline void save_construct_data(
74     Archive & /*ar*/, 
75     const T * /*t*/, 
76     const unsigned int /*file_version */
77 ){
78     // default is to save no data because default constructor
79     // requires no arguments.
80 }
81
82 // load data required for construction and invoke constructor in place
83 template<class Archive, class T>
84 inline void load_construct_data(
85     Archive & /*ar*/, 
86     T * t, 
87     const unsigned int /*file_version*/
88 ){
89     // default just uses the default constructor.  going
90     // through access permits usage of otherwise private default
91     // constructor
92     access::construct(t);
93 }
94
95 /////////////////////////////////////////////////////////////////////////////
96 // layer 3 - move call into serialization namespace so that ADL will function
97 // in the manner we desire.
98 //
99 // on compilers which don't implement ADL. only the current namespace
100 // i.e. boost::serialization will be searched.
101 // 
102 // on compilers which DO implement ADL
103 // serialize overrides can be in any of the following
104 // 
105 // 1) same namepace as Archive
106 // 2) same namespace as T
107 // 3) boost::serialization
108 //
109 // Due to Martin Ecker
110
111 template<class Archive, class T>
112 inline void serialize_adl(
113     Archive & ar, 
114     T & t, 
115     const unsigned int file_version
116 ){
117     // note usage of function overloading to delay final resolution
118     // until the point of instantiation.  This works around the two-phase
119     // lookup "feature" which inhibits redefintion of a default function
120     // template implementation. Due to Robert Ramey
121     //
122     // Note that this trick generates problems for compiles which don't support
123     // PFTO, suppress it here.  As far as we know, there are no compilers
124     // which fail to support PFTO while supporting two-phase lookup.
125     const version_type v(file_version);
126     serialize(ar, t, v);
127 }
128
129 template<class Archive, class T>
130 inline void save_construct_data_adl(
131     Archive & ar, 
132     const T * t, 
133     const unsigned int file_version
134 ){
135     // see above
136     const version_type v(file_version);
137     save_construct_data(ar, t, v);
138 }
139
140 template<class Archive, class T>
141 inline void load_construct_data_adl(
142     Archive & ar, 
143     T * t, 
144     const unsigned int file_version
145 ){
146     // see above comment
147     const version_type v(file_version);
148     load_construct_data(ar, t, v);
149 }
150
151 } // namespace serialization
152 } // namespace boost
153
154 #endif //BOOST_SERIALIZATION_SERIALIZATION_HPP