X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=boost_ext%2Fboost%2Fmulti_index%2Fidentity.hpp;fp=boost_ext%2Fboost%2Fmulti_index%2Fidentity.hpp;h=b3c95680357cac49e671e59beff438eca892ca7a;hb=4123b4fe58a7fd4659fa01476581690b47c83600;hp=0000000000000000000000000000000000000000;hpb=79564b90f6c9f7cd0bc5b11a6146bb7067b11a75;p=senf.git

diff --git a/boost_ext/boost/multi_index/identity.hpp b/boost_ext/boost/multi_index/identity.hpp
new file mode 100644
index 0000000..b3c9568
--- /dev/null
+++ b/boost_ext/boost/multi_index/identity.hpp
@@ -0,0 +1,147 @@
+/* Copyright 2003-2006 Joaquín M López Muñoz.
+ * 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/multi_index for library home page.
+ */
+
+#ifndef BOOST_MULTI_INDEX_IDENTITY_HPP
+#define BOOST_MULTI_INDEX_IDENTITY_HPP
+
+#if defined(_MSC_VER)&&(_MSC_VER>=1200)
+#pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/multi_index/identity_fwd.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#if !defined(BOOST_NO_SFINAE)
+#include <boost/type_traits/is_convertible.hpp>
+#endif
+
+namespace boost{
+
+template<class Type> class reference_wrapper; /* fwd decl. */
+
+namespace multi_index{
+
+namespace detail{
+
+/* identity is a do-nothing key extractor that returns the [const] Type&
+ * object passed.
+ * Additionally, identity is overloaded to support referece_wrappers
+ * of Type and "chained pointers" to Type's. By chained pointer to Type we
+ * mean a  type  P such that, given a p of type P
+ *   *...n...*x is convertible to Type&, for some n>=1.
+ * Examples of chained pointers are raw and smart pointers, iterators and
+ * arbitrary combinations of these (vg. Type** or auto_ptr<Type*>.)
+ */
+
+/* NB. Some overloads of operator() have an extra dummy parameter int=0.
+ * This disambiguator serves several purposes:
+ *  - Without it, MSVC++ 6.0 incorrectly regards some overloads as
+ *    specializations of a previous member function template.
+ *  - MSVC++ 6.0/7.0 seem to incorrectly treat some different memfuns
+ *    as if they have the same signature.
+ *  - If remove_const is broken due to lack of PTS, int=0 avoids the
+ *    declaration of memfuns with identical signature.
+ */
+
+template<typename Type>
+struct const_identity_base
+{
+  typedef Type result_type;
+
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type
+#else
+  Type&
+#endif 
+  
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  Type& operator()(Type& x)const
+  {
+    return x;
+  }
+
+  Type& operator()(const reference_wrapper<Type>& x)const
+  { 
+    return x.get();
+  }
+
+  Type& operator()(
+    const reference_wrapper<typename remove_const<Type>::type>& x,int=0)const
+  { 
+    return x.get();
+  }
+};
+
+template<typename Type>
+struct non_const_identity_base
+{
+  typedef Type result_type;
+
+  /* templatized for pointer-like types */
+  
+  template<typename ChainedPtr>
+
+#if !defined(BOOST_NO_SFINAE)
+  typename disable_if<
+    is_convertible<const ChainedPtr&,const Type&>,Type&>::type
+#else
+  Type&
+#endif 
+    
+  operator()(const ChainedPtr& x)const
+  {
+    return operator()(*x);
+  }
+
+  const Type& operator()(const Type& x,int=0)const
+  {
+    return x;
+  }
+
+  Type& operator()(Type& x)const
+  {
+    return x;
+  }
+
+  const Type& operator()(const reference_wrapper<const Type>& x,int=0)const
+  { 
+    return x.get();
+  }
+
+  Type& operator()(const reference_wrapper<Type>& x)const
+  { 
+    return x.get();
+  }
+};
+
+} /* namespace multi_index::detail */
+
+template<class Type>
+struct identity:
+  mpl::if_c<
+    is_const<Type>::value,
+    detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
+  >::type
+{
+};
+
+} /* namespace multi_index */
+
+} /* namespace boost */
+
+#endif