276 lines
9.0 KiB
C++
276 lines
9.0 KiB
C++
#ifndef BOOST_SERIALIZATION_SMART_CAST_HPP
|
|
#define BOOST_SERIALIZATION_SMART_CAST_HPP
|
|
|
|
// MS compatible compilers support #pragma once
|
|
#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(__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 typename mpl::eval_if<
|
|
typename mpl::and_<
|
|
mpl::not_<is_base_and_derived<
|
|
typename remove_reference< T >::type,
|
|
U
|
|
> >,
|
|
mpl::not_<is_base_and_derived<
|
|
U,
|
|
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){
|
|
typedef typename mpl::eval_if<
|
|
boost::is_polymorphic<U>,
|
|
mpl::identity<polymorphic>,
|
|
mpl::identity<non_polymorphic>
|
|
>::type typex;
|
|
return typex::cast(u);
|
|
}
|
|
};
|
|
|
|
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_exception(std::bad_cast());
|
|
#endif
|
|
return tmp;
|
|
}
|
|
};
|
|
|
|
template<class U>
|
|
static T cast(U * u){
|
|
typedef
|
|
typename mpl::eval_if<
|
|
typename mpl::and_<
|
|
mpl::not_<is_base_and_derived<
|
|
typename remove_pointer< T >::type,
|
|
U
|
|
> >,
|
|
mpl::not_<is_base_and_derived<
|
|
U,
|
|
typename remove_pointer< T >::type
|
|
> >
|
|
>,
|
|
// borland chokes w/o full qualification here
|
|
mpl::identity<cross>,
|
|
mpl::identity<linear>
|
|
>::type typex;
|
|
return typex::cast(u);
|
|
}
|
|
#else
|
|
template<class U>
|
|
static T cast(U * u){
|
|
T tmp = dynamic_cast< T >(u);
|
|
#ifndef NDEBUG
|
|
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){
|
|
typedef typename mpl::eval_if<
|
|
boost::is_polymorphic<U>,
|
|
mpl::identity<polymorphic>,
|
|
mpl::identity<non_polymorphic>
|
|
>::type typex;
|
|
return typex::cast(u);
|
|
}
|
|
|
|
};
|
|
|
|
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){
|
|
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
|
|
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
|
|
typename mpl::eval_if<boost::is_pointer<U>,
|
|
mpl::identity<smart_cast_impl::pointer< T > >,
|
|
// else
|
|
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
|