Swift
summaryrefslogtreecommitdiffstats
path: root/3rdParty/Boost/src/boost/serialization/smart_cast.hpp
diff options
context:
space:
mode:
authorTobias Markmann <tm@ayena.de>2014-10-19 20:22:58 (GMT)
committerTobias Markmann <tm@ayena.de>2014-10-20 13:49:33 (GMT)
commit6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch)
tree2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/serialization/smart_cast.hpp
parent38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff)
downloadswift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip
swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0. Updated our update.sh script to stop on error. Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to missing include of <iostream> with newer Boost. Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/serialization/smart_cast.hpp')
-rw-r--r--3rdParty/Boost/src/boost/serialization/smart_cast.hpp38
1 files changed, 20 insertions, 18 deletions
diff --git a/3rdParty/Boost/src/boost/serialization/smart_cast.hpp b/3rdParty/Boost/src/boost/serialization/smart_cast.hpp
index c240a55..02edb4b 100644
--- a/3rdParty/Boost/src/boost/serialization/smart_cast.hpp
+++ b/3rdParty/Boost/src/boost/serialization/smart_cast.hpp
@@ -1,301 +1,303 @@
#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
#define BOOST_SERIALIZATION_SMART_CAST_HPP
// MS compatible compilers support #pragma once
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#if defined(_MSC_VER)
# pragma once
#endif
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// smart_cast.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/libs/serialization for updates, documentation, and revision history.
// casting of pointers and references.
// In casting between different C++ classes, there are a number of
// rules that have to be kept in mind in deciding whether to use
// static_cast or dynamic_cast.
// a) dynamic casting can only be applied when one of the types is polymorphic
// Otherwise static_cast must be used.
// b) only dynamic casting can do runtime error checking
// use of static_cast is generally un checked even when compiled for debug
// c) static_cast would be considered faster than dynamic_cast.
// If casting is applied to a template parameter, there is no apriori way
// to know which of the two casting methods will be permitted or convenient.
// smart_cast uses C++ type_traits, and program debug mode to select the
// most convenient cast to use.
#include <exception>
#include <typeinfo>
#include <cstddef> // NULL
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/type_traits/is_pointer.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/identity.hpp>
+#include <boost/serialization/throw_exception.hpp>
+
namespace boost {
namespace serialization {
namespace smart_cast_impl {
template<class T>
struct reference {
struct polymorphic {
struct linear {
template<class U>
static T cast(U & u){
return static_cast< T >(u);
}
};
struct cross {
template<class U>
static T cast(U & u){
return dynamic_cast< T >(u);
}
};
template<class U>
static T cast(U & u){
// if we're in debug mode
#if ! defined(NDEBUG) \
|| defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) \
|| defined(__MWERKS__)
// do a checked dynamic cast
return cross::cast(u);
#else
// borland 5.51 chokes here so we can't use it
// note: if remove_reference isn't function for these types
// cross casting will be selected this will work but will
// not be the most efficient method. This will conflict with
// the original smart_cast motivation.
- typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
- BOOST_DEDUCED_TYPENAME mpl::and_<
+ typedef typename mpl::eval_if<
+ typename mpl::and_<
mpl::not_<is_base_and_derived<
- BOOST_DEDUCED_TYPENAME remove_reference< T >::type,
+ typename remove_reference< T >::type,
U
> >,
mpl::not_<is_base_and_derived<
U,
- BOOST_DEDUCED_TYPENAME remove_reference< T >::type
+ typename remove_reference< T >::type
> >
>,
// borland chokes w/o full qualification here
mpl::identity<cross>,
mpl::identity<linear>
>::type typex;
// typex works around gcc 2.95 issue
return typex::cast(u);
#endif
}
};
struct non_polymorphic {
template<class U>
static T cast(U & u){
return static_cast< T >(u);
}
};
template<class U>
static T cast(U & u){
#if defined(__BORLANDC__)
return mpl::eval_if<
boost::is_polymorphic<U>,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type::cast(u);
#else
- typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ typedef typename mpl::eval_if<
boost::is_polymorphic<U>,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type typex;
return typex::cast(u);
#endif
}
};
template<class T>
struct pointer {
struct polymorphic {
// unfortunately, this below fails to work for virtual base
// classes. need has_virtual_base to do this.
// Subject for further study
#if 0
struct linear {
template<class U>
static T cast(U * u){
return static_cast< T >(u);
}
};
struct cross {
template<class U>
static T cast(U * u){
T tmp = dynamic_cast< T >(u);
#ifndef NDEBUG
- if ( tmp == 0 ) throw std::bad_cast();
+ if ( tmp == 0 ) throw_exception(std::bad_cast());
#endif
return tmp;
}
};
template<class U>
static T cast(U * u){
// if we're in debug mode
- #if ! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
+ #if 0 //! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x560)
// do a checked dynamic cast
return cross::cast(u);
#else
// borland 5.51 chokes here so we can't use it
// note: if remove_pointer isn't function for these types
// cross casting will be selected this will work but will
// not be the most efficient method. This will conflict with
// the original smart_cast motivation.
typedef
- BOOST_DEDUCED_TYPENAME mpl::eval_if<
- BOOST_DEDUCED_TYPENAME mpl::and_<
+ typename mpl::eval_if<
+ typename mpl::and_<
mpl::not_<is_base_and_derived<
- BOOST_DEDUCED_TYPENAME remove_pointer< T >::type,
+ typename remove_pointer< T >::type,
U
> >,
mpl::not_<is_base_and_derived<
U,
- BOOST_DEDUCED_TYPENAME remove_pointer< T >::type
+ typename remove_pointer< T >::type
> >
>,
// borland chokes w/o full qualification here
mpl::identity<cross>,
mpl::identity<linear>
>::type typex;
return typex::cast(u);
#endif
}
#else
template<class U>
static T cast(U * u){
T tmp = dynamic_cast< T >(u);
#ifndef NDEBUG
- if ( tmp == 0 ) throw std::bad_cast();
+ if ( tmp == 0 ) throw_exception(std::bad_cast());
#endif
return tmp;
}
#endif
};
struct non_polymorphic {
template<class U>
static T cast(U * u){
return static_cast< T >(u);
}
};
template<class U>
static T cast(U * u){
#if defined(__BORLANDC__)
return mpl::eval_if<
boost::is_polymorphic<U>,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type::cast(u);
#else
- typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ typedef typename mpl::eval_if<
boost::is_polymorphic<U>,
mpl::identity<polymorphic>,
mpl::identity<non_polymorphic>
>::type typex;
return typex::cast(u);
#endif
}
};
template<class TPtr>
struct void_pointer {
template<class UPtr>
static TPtr cast(UPtr uptr){
return static_cast<TPtr>(uptr);
}
};
template<class T>
struct error {
// if we get here, its because we are using one argument in the
// cast on a system which doesn't support partial template
// specialization
template<class U>
static T cast(U u){
BOOST_STATIC_ASSERT(sizeof(T)==0);
return * static_cast<T *>(NULL);
}
};
} // smart_cast_impl
// this implements:
// smart_cast<Target *, Source *>(Source * s)
// smart_cast<Target &, Source &>(s)
// note that it will fail with
// smart_cast<Target &>(s)
template<class T, class U>
T smart_cast(U u) {
typedef
- BOOST_DEDUCED_TYPENAME mpl::eval_if<
- BOOST_DEDUCED_TYPENAME mpl::or_<
+ typename mpl::eval_if<
+ typename mpl::or_<
boost::is_same<void *, U>,
boost::is_same<void *, T>,
boost::is_same<const void *, U>,
boost::is_same<const void *, T>
>,
mpl::identity<smart_cast_impl::void_pointer< T > >,
// else
- BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_pointer<U>,
+ typename mpl::eval_if<boost::is_pointer<U>,
mpl::identity<smart_cast_impl::pointer< T > >,
// else
- BOOST_DEDUCED_TYPENAME mpl::eval_if<boost::is_reference<U>,
+ typename mpl::eval_if<boost::is_reference<U>,
mpl::identity<smart_cast_impl::reference< T > >,
// else
mpl::identity<smart_cast_impl::error< T >
>
>
>
>::type typex;
return typex::cast(u);
}
// this implements:
// smart_cast_reference<Target &>(Source & s)
template<class T, class U>
T smart_cast_reference(U & u) {
return smart_cast_impl::reference< T >::cast(u);
}
} // namespace serialization
} // namespace boost
#endif // BOOST_SERIALIZATION_SMART_CAST_HPP