#ifndef BOOST_REF_HPP_INCLUDED #define BOOST_REF_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif #include <boost/config.hpp> #include <boost/utility/addressof.hpp> #include <boost/mpl/bool.hpp> #include <boost/detail/workaround.hpp> // // ref.hpp - ref/cref, useful helper functions // // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001, 2002 Peter Dimov // Copyright (C) 2002 David Abrahams // // Distributed under 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/bind/ref.html for documentation. // namespace boost { template<class T> class reference_wrapper { public: typedef T type; #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) explicit reference_wrapper(T& t): t_(&t) {} #else explicit reference_wrapper(T& t): t_(boost::addressof(t)) {} #endif operator T& () const { return *t_; } T& get() const { return *t_; } T* get_pointer() const { return t_; } private: T* t_; }; # if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) ) # define BOOST_REF_CONST # else # define BOOST_REF_CONST const # endif template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t) { return reference_wrapper<T>(t); } template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t) { return reference_wrapper<T const>(t); } # undef BOOST_REF_CONST # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template<typename T> class is_reference_wrapper : public mpl::false_ { }; template<typename T> class unwrap_reference { public: typedef T type; }; # define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \ template<typename T> \ class is_reference_wrapper< X > \ : public mpl::true_ \ { \ }; \ \ template<typename T> \ class unwrap_reference< X > \ { \ public: \ typedef T type; \ }; \ /**/ AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T>) #if !defined(BOOST_NO_CV_SPECIALIZATIONS) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> volatile) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper<T> const volatile) #endif # undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF # else // no partial specialization } // namespace boost #include <boost/type.hpp> namespace boost { namespace detail { typedef char (&yes_reference_wrapper_t)[1]; typedef char (&no_reference_wrapper_t)[2]; no_reference_wrapper_t is_reference_wrapper_test(...); template<typename T> yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper<T> >); template<bool wrapped> struct reference_unwrapper { template <class T> struct apply { typedef T type; }; }; template<> struct reference_unwrapper<true> { template <class T> struct apply { typedef typename T::type type; }; }; } template<typename T> class is_reference_wrapper { public: BOOST_STATIC_CONSTANT( bool, value = ( sizeof(detail::is_reference_wrapper_test(type<T>())) == sizeof(detail::yes_reference_wrapper_t))); typedef ::boost::mpl::bool_<value> type; }; template <typename T> class unwrap_reference : public detail::reference_unwrapper< is_reference_wrapper<T>::value >::template apply<T> {}; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <class T> inline typename unwrap_reference<T>::type& unwrap_ref(T& t) { return t; } template<class T> inline T* get_pointer( reference_wrapper<T> const & r ) { return r.get_pointer(); } } // namespace boost #endif // #ifndef BOOST_REF_HPP_INCLUDED