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
|
#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
#define BOOST_SERIALIZATION_BASE_OBJECT_HPP
// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// base_object.hpp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for updates, documentation, and revision history.
// if no archive headers have been included this is a no op
// this is to permit BOOST_EXPORT etc to be included in a
// file declaration header
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/static_assert.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/void_cast_fwd.hpp>
namespace boost {
namespace serialization {
namespace detail
{
// get the base type for a given derived type
// preserving the const-ness
template<class B, class D>
struct base_cast
{
typedef typename
mpl::if_<
is_const<D>,
const B,
B
>::type type;
BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
};
// only register void casts if the types are polymorphic
template<class Base, class Derived>
struct base_register
{
struct polymorphic {
static void const * invoke(){
Base const * const b = 0;
Derived const * const d = 0;
return & void_cast_register(d, b);
}
};
struct non_polymorphic {
static void const * invoke(){
return 0;
}
};
static void const * invoke(){
typedef typename mpl::eval_if<
is_polymorphic<Base>,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type type;
return type::invoke();
}
};
} // namespace detail
#if defined(__BORLANDC__) && __BORLANDC__ < 0x610
template<class Base, class Derived>
const Base &
base_object(const Derived & d)
{
BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
detail::base_register<Base, Derived>::invoke();
return access::cast_reference<const Base, Derived>(d);
}
#else
template<class Base, class Derived>
typename detail::base_cast<Base, Derived>::type &
base_object(Derived &d)
{
BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
typedef typename detail::base_cast<Base, Derived>::type type;
detail::base_register<type, Derived>::invoke();
return access::cast_reference<type, Derived>(d);
}
#endif
} // namespace serialization
} // namespace boost
#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
|
Swift