整理

include/boost/container/detail/compare_functors.hpp

@@ -0,0 +1,155 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. 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/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP
+#define BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/intrusive/detail/ebo_functor_holder.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+namespace boost {
+namespace container {
+
+template<class ValueType>
+class equal_to_value
+{
+   typedef ValueType value_type;
+   const value_type &t_;
+
+   public:
+   inline explicit equal_to_value(const value_type &t)
+      :  t_(t)
+   {}
+
+   template <class U>
+   inline bool operator()(const U &t)const
+   {
+      return t_ == t;
+   }
+};
+
+template<class ValueType>
+class equal_to_value_first
+{
+   typedef ValueType value_type;
+   const value_type &t_;
+
+   public:
+   inline explicit equal_to_value_first(const value_type &t)
+      :  t_(t)
+   {}
+
+   template <class U>
+   inline bool operator()(const U &t)const
+   {
+      return t_ == t.first;
+   }
+};
+
+template<class Node, class Pred, class Ret = bool>
+struct value_to_node_compare
+   :  Pred
+{
+   typedef Pred predicate_type;
+   typedef Node node_type;
+
+   inline value_to_node_compare()
+      : Pred()
+   {}
+
+   inline explicit value_to_node_compare(Pred pred)
+      :  Pred(pred)
+   {}
+
+   inline Ret operator()(const Node &a, const Node &b) const
+   {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
+
+   inline Ret operator()(const Node &a) const
+   {  return static_cast<const Pred&>(*this)(a.get_data());  }
+
+   inline Ret operator()(const Node &a, const Node &b)
+   {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
+
+   inline Ret operator()(const Node &a)
+   {  return static_cast<Pred&>(*this)(a.get_data());  }
+
+   inline predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
+   inline const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
+};
+
+template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
+struct key_node_pred
+   :  public boost::intrusive::detail::ebo_functor_holder<KeyPred>
+{
+   inline explicit key_node_pred(const KeyPred &comp)
+      :  base_t(comp)
+   {}
+
+   inline explicit key_node_pred()
+   {}
+
+   typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
+   typedef KeyPred                     key_predicate;
+   typedef KeyOfValue                  key_of_value;
+   typedef typename KeyOfValue::type   key_type;
+
+
+   inline static const key_type &key_from(const Node &n)
+   {
+      return key_of_value()(n.get_data());
+   }
+
+   template <class T>
+   inline static const T &
+      key_from(const T &t)
+   {  return t;  }
+
+   inline const key_predicate &key_pred() const
+   {  return static_cast<const key_predicate &>(*this);  }
+
+   inline key_predicate &key_pred()
+   {  return static_cast<key_predicate &>(*this);  }
+
+   inline Ret operator()(const key_type &key) const
+   {  return this->key_pred()(key);  }
+
+   template<class U>
+   inline Ret operator()(const U &nonkey) const
+   {  return this->key_pred()(this->key_from(nonkey));  }
+
+   inline bool operator()(const key_type &key1, const key_type &key2) const
+   {  return this->key_pred()(key1, key2);  }
+
+   template<class U>
+   inline bool operator()(const key_type &key1, const U &nonkey2) const
+   {  return this->key_pred()(key1, this->key_from(nonkey2));  }
+
+   template<class U>
+   inline bool operator()(const U &nonkey1, const key_type &key2) const
+   {  return this->key_pred()(this->key_from(nonkey1), key2);  }
+
+   template<class U, class V>
+   inline bool operator()(const U &nonkey1, const V &nonkey2) const
+   {  return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2));  }
+};
+
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //BOOST_CONTAINER_DETAIL_COMPARE_FUNCTORS_HPP