Changeset 2286

Timestamp:

Jun 27, 2010, 5:55:32 AM (13 years ago)

Author:

Peter

Message:

replace class PtrCompare? with two function make_ptr_compare that return compose_f_gx_hy functors. closes #632

Location:

trunk

Files:

• test/utility_test.cc (modified) (1 diff)
• yat/utility/stl_utility.h (modified) (5 diffs)

trunk/test/utility_test.cc

@@ -470 +470 @@
 void test_ptr_compare(test::Suite& suite)
 {
-  double* a = new double(0);
-  double* b = new double(1);
-
-  utility::PtrCompare<double> ptr_less;
-  if (!ptr_less(a, b)) {
-    suite.out() << "ptr_less(a, b) returned false\n";
-    suite.add(false);
-  }
-  if (ptr_less(b, a)) {
-    suite.out() << "ptr_less(b, a) returned true\n";
-    suite.add(false);
-  }
-
-  utility::PtrCompare<double, std::greater<double> > ptr_greater;
-  if (ptr_greater(a, b)) {
-    suite.out() << "ptr_greater(a, b) returned true\n";
-    suite.add(false);
-  }
-  if (!ptr_greater(b, a)) {
-    suite.out() << "ptr_greater(b, a) returned false\n";
-    suite.add(false);
-  }
-  delete a;
-  delete b;
-
+  using utility::make_ptr_compare;
   std::vector<double*> vec(10);
   std::greater<double> d_greater;
-  utility::PtrCompare<double, std::greater<double> > ptr_greater2(d_greater);
   for (size_t i=0; i<vec.size(); ++i)
     vec[i] = new double(i);
-  std::sort(vec.begin(), vec.end(), ptr_greater2);
+  std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin(), d_greater));
   for (size_t i=1; i<vec.size(); ++i) {
     suite.add( *vec[i-1] > *vec[i]);
   }
+  std::sort(vec.begin(), vec.end(), make_ptr_compare(*vec.begin()));
+  for (size_t i=1; i<vec.size(); ++i) {
+    suite.add( *vec[i-1] < *vec[i]);
+  }
   for (size_t i=0; i<vec.size(); ++i)
     delete vec[i];

trunk/yat/utility/stl_utility.h

@@ -35 +35 @@
 ///
 
+#include "concept_check.h"
 #include "DataWeight.h"
 #include "Exception.h"
@@ -100 +101 @@
      by <a href=http://www.sgi.com/tech/stl/iterator_traits.html>
      std::iterator_traits </a>.
+
+     \since New in yat 0.7
    */
   template<typename Pointer>
@@ -106 +109 @@
                                typename std::iterator_traits<Pointer>::reference>
   {
+    /**
+       \brief constructor
+     */
+    Dereferencer(void) 
+    { BOOST_CONCEPT_ASSERT((TrivialIterator<Pointer>)); }
+
     /**
        \return * \a ti
@@ -677 +686 @@
 
   /**
-     Adaptor class that can be used to compare pointers, T*, when you
-     want to compare them with respect to the objects they point to.
+     Convenient function that creates a binary predicate that can be
+     used to compare pointers when you want to compare them with
+     respect to the objects they point to.
 
      Example:
@@ -684 +694 @@
      std::vector<MyClass*> vec(18);
      ...
-     PtrCompare<MyClass, std::greater<MyClass> > ptr_compare;
-     std::sort(vec.begin(), vec.end(), ptr_compare);
+     std::sort(vec.begin(), vec.end(), 
+               make_ptr_compare(vec[0], std::greater<MyClass>());
      \endcode
 
-     The class Compare must be a <a
-     href="http://www.sgi.com/tech/stl/BinaryFunction.html">binary
-     functor</a> that takes two \c const \c T& and returns \c bool.
+
+     Type Requirement:
+     - \a compare must be a <a
+     href="http://www.sgi.com/tech/stl/AdaptableBinaryPredicate.html">Adaptable
+     Binary Predicate</a>.
+     - value_type of Pointer must be convertible to argument_type of
+       compare
+
+     \return a compose_f_gx_hy in which \c F is defined by \a compare
+     and both \c G and \c H are \c Dereferencer functors.
+
+     \see compose_f_gx_hy
 
      \since New in yat 0.7
    */
-  template<typename T, class Compare = std::less<T> >
-  class PtrCompare : std::binary_function<T const* const, T const* const, bool>
-  {
-  public:
-    /**
-       \brief Constructor.
-
-       Creates an instance of Compare using its default constructor.
-     */
-    PtrCompare(void)
-    {
-      BOOST_CONCEPT_ASSERT((boost::BinaryFunction<Compare, bool, const T&, 
-                            const T&>));
-    }
-
-    /**
-       \brief Constructor.
-
-       Creates a copy of \a c that will be used later.
-     */
-    PtrCompare(Compare c)
-      : compare_(c) 
-    {
-      BOOST_CONCEPT_ASSERT((boost::BinaryFunction<Compare, bool, const T&, 
-                            const T&>));
-    }
-
-    /**
-       \return true iff Compare(* \a lhs, * \a rhs ) is true.
-     */
-    bool operator()(T const* const lhs, T const* const rhs) const
-    { 
-      return compare_(*lhs, *rhs); 
-    }
-  private:
-    Compare compare_;
-
-    // using compiler generated copy
-    // PtrCompare(const PtrCompare&)
-    // PtrCompare& operator=(const PtrCompare&)
-  };
+  template<typename Pointer, class Compare>
+  compose_f_gx_hy<Compare, Dereferencer<Pointer>, Dereferencer<Pointer> >
+  make_ptr_compare(Pointer p, Compare compare)
+  {
+    return make_compose_f_gx_hy(compare, Dereferencer<Pointer>(),
+                                Dereferencer<Pointer>());
+  }
+
+  /**
+     Same as make_ptr_compare(2) except that std::less is used to
+     compare pointers.
+
+     \since New in yat 0.7
+   */
+  template<typename Pointer>
+  compose_f_gx_hy<std::less<typename std::iterator_traits<Pointer>::value_type>,
+                  Dereferencer<Pointer>, Dereferencer<Pointer> >
+  make_ptr_compare(Pointer p)
+  {
+    typedef typename std::iterator_traits<Pointer>::value_type value_type;
+    BOOST_CONCEPT_ASSERT((boost::LessThanComparable<value_type>));
+    std::less<value_type> compare;
+    return make_ptr_compare(p, compare);
+  }
+
 
   ///