--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/python/type_id.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,191 @@
+// Copyright David Abrahams 2002.
+// 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)
+#ifndef TYPE_ID_DWA2002517_HPP
+# define TYPE_ID_DWA2002517_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/detail/msvc_typeinfo.hpp>
+# include <boost/operators.hpp>
+# include <typeinfo>
+# include <cstring>
+# include <boost/static_assert.hpp>
+# include <boost/detail/workaround.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type_traits/broken_compiler_spec.hpp>
+
+# ifndef BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
+# if defined(__GNUC__) \
+ && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))) \
+ && !defined(__EDG_VERSION__)
+# define BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
+# endif
+# endif
+
+namespace boost { namespace python {
+
+// for this compiler at least, cross-shared-library type_info
+// comparisons don't work, so use typeid(x).name() instead. It's not
+// yet clear what the best default strategy is.
+# if (defined(__GNUC__) && __GNUC__ >= 3) \
+ || defined(_AIX) \
+ || ( defined(__sgi) && defined(__host_mips)) \
+ || (defined(__hpux) && defined(__HP_aCC)) \
+ || (defined(linux) && defined(__INTEL_COMPILER) && defined(__ICC))
+# define BOOST_PYTHON_TYPE_ID_NAME
+# endif
+
+#ifdef BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
+// Runtime detection of broken cxxabi::__cxa_demangle versions,
+// to avoid #ifdef clutter.
+bool cxxabi_cxa_demangle_is_broken();
+#define BOOST_PYTHON_HAVE_CXXABI_CXA_DEMANGLE_IS_BROKEN
+#endif
+
+// type ids which represent the same information as std::type_info
+// (i.e. the top-level reference and cv-qualifiers are stripped), but
+// which works across shared libraries.
+struct type_info : private totally_ordered<type_info>
+{
+ inline type_info(std::type_info const& = typeid(void));
+
+ inline bool operator<(type_info const& rhs) const;
+ inline bool operator==(type_info const& rhs) const;
+
+ char const* name() const;
+ friend BOOST_PYTHON_DECL std::ostream& operator<<(
+ std::ostream&, type_info const&);
+
+ private: // data members
+# ifdef BOOST_PYTHON_TYPE_ID_NAME
+ typedef char const* base_id_t;
+# else
+ typedef std::type_info const* base_id_t;
+# endif
+
+ base_id_t m_base_type;
+};
+
+# ifdef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
+# define BOOST_PYTHON_EXPLICIT_TT_DEF(T) ::boost::type<T>*
+# else
+# define BOOST_PYTHON_EXPLICIT_TT_DEF(T)
+# endif
+
+template <class T>
+inline type_info type_id(BOOST_EXPLICIT_TEMPLATE_TYPE(T))
+{
+ return type_info(
+# if !defined(_MSC_VER) \
+ || (!BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+ && !BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 700))
+ typeid(T)
+# else // strip the decoration which msvc and Intel mistakenly leave in
+ python::detail::msvc_typeid((boost::type<T>*)0)
+# endif
+ );
+}
+
+# if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
+ || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
+// Older EDG-based compilers seems to mistakenly distinguish "int" from
+// "signed int", etc., but only in typeid() expressions. However
+// though int == signed int, the "signed" decoration is propagated
+// down into template instantiations. Explicit specialization stops
+// that from taking hold.
+
+# define BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(T) \
+template <> \
+inline type_info type_id<T>(BOOST_PYTHON_EXPLICIT_TT_DEF(T)) \
+{ \
+ return type_info(typeid(T)); \
+}
+
+BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(short)
+BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(int)
+BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(long)
+// using Python's macro instead of Boost's - we don't seem to get the
+// config right all the time.
+# ifdef HAVE_LONG_LONG
+BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID(long long)
+# endif
+# undef BOOST_PYTHON_SIGNED_INTEGRAL_TYPE_ID
+# endif
+
+//
+inline type_info::type_info(std::type_info const& id)
+ : m_base_type(
+# ifdef BOOST_PYTHON_TYPE_ID_NAME
+ id.name()
+# else
+ &id
+# endif
+ )
+{
+}
+
+inline bool type_info::operator<(type_info const& rhs) const
+{
+# ifdef BOOST_PYTHON_TYPE_ID_NAME
+ return std::strcmp(m_base_type, rhs.m_base_type) < 0;
+# else
+ return m_base_type->before(*rhs.m_base_type);
+# endif
+}
+
+inline bool type_info::operator==(type_info const& rhs) const
+{
+# ifdef BOOST_PYTHON_TYPE_ID_NAME
+ return !std::strcmp(m_base_type, rhs.m_base_type);
+# else
+ return *m_base_type == *rhs.m_base_type;
+# endif
+}
+
+# ifdef BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
+namespace detail
+{
+ BOOST_PYTHON_DECL char const* gcc_demangle(char const*);
+}
+# endif
+
+inline char const* type_info::name() const
+{
+ char const* raw_name
+ = m_base_type
+# ifndef BOOST_PYTHON_TYPE_ID_NAME
+ ->name()
+# endif
+ ;
+
+# ifdef BOOST_PYTHON_HAVE_GCC_CP_DEMANGLE
+ return detail::gcc_demangle(raw_name);
+# else
+ return raw_name;
+# endif
+}
+
+
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_info const&);
+
+# if !BOOST_WORKAROUND(BOOST_MSVC, == 1200)
+template<>
+inline type_info type_id<void>(BOOST_PYTHON_EXPLICIT_TT_DEF(void))
+{
+ return type_info (typeid (void *));
+}
+# ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
+template<>
+inline type_info type_id<const volatile void>(BOOST_PYTHON_EXPLICIT_TT_DEF(const volatile void))
+{
+ return type_info (typeid (void *));
+}
+# endif
+
+# endif
+
+}} // namespace boost::python
+
+#endif // TYPE_ID_DWA2002517_HPP