#ifndef BOOST_SMART_CAST_HPP

#define BOOST_SMART_CAST_HPP

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)

# 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 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 <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>

namespace boost {

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_<

                                mpl::not_<is_base_and_derived<

                                    BOOST_DEDUCED_TYPENAME remove_reference<T>::type,

                                    U

                                > >,

                                mpl::not_<is_base_and_derived<

                                    U,

                                    BOOST_DEDUCED_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<

                    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();

                    #endif

                    return tmp;

                }

            };

            template<class U>

            static T cast(U * u){

                // if we're in debug mode

                #if ! 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_<

                                mpl::not_<is_base_and_derived<

                                    BOOST_DEDUCED_TYPENAME remove_pointer<T>::type,

                                    U

                                > >,

                                mpl::not_<is_base_and_derived<

                                    U,

                                    BOOST_DEDUCED_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();

                #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<

                    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_<

                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>,

            mpl::identity<smart_cast_impl::pointer<T> >,

        // else

        BOOST_DEDUCED_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 boost

#endif // BOOST_SMART_CAST_HPP