problems with the current boost's functional, projection_iterator

From: Levente Farkas (lfarkas_at_[hidden])
Date: 2001-10-04 11:24:48

hi,
there is a functional.hpp which enhanced function object adaptors, but
it doesn't contain the sgi's extensions like unary_compose, compose1...
on the other hand compose.hpp doesn't use call_traits so there can be
"references to references" problem same as with the original functional
and sgi's implementation. the same problem occur with bind.hpp.
the possible solutions:
std::compose1(f, g)
boost::compose_f_gx(f, g)
boost::bind(f, boost::bind(g, _1))
Lambda Library is not usable on MSVC:-(
so I think it'd be useful to extend the functional.hpp for sgi extension
too. I attached my patch for functional.hpp (I try to use exactly the same
coding convention)
 
 -- Levente                               "Si vis pacem para bellum!"


--- ./boost/functional.hpp.lfarkas	Thu Oct  4 13:41:03 2001
+++ ./boost/functional.hpp	Thu Oct  4 15:50:30 2001
@@ -313,6 +313,93 @@
         return binder2nd<Operation>(op, x);
     }
 
+
+    // --------------------------------------------------------------------------
+    // unary_compose, compose1
+    // --------------------------------------------------------------------------
+    template <class Operation1, class Operation2>
+    class unary_compose
+      : public std::unary_function<typename unary_traits<Operation2>::argument_type,
+                                   typename unary_traits<Operation1>::result_type>
+    {
+      protected:
+        typename unary_traits<Operation1>::function_type op1;
+        typename unary_traits<Operation2>::function_type op2;
+      public:
+        unary_compose(typename unary_traits<Operation1>::param_type x,
+                      typename unary_traits<Operation2>::param_type y)
+            :
+            op1(x), op2(y) 
+            {}
+
+        typename unary_traits<Operation1>::result_type
+        operator()(typename call_traits<typename unary_traits<Operation2>::argument_type>::param_type x) const
+        {
+            return op1(op2(x));
+        }
+    };
+
+    template <class Operation1, class Operation2>
+    inline unary_compose<Operation1, Operation2>
+    compose1(const Operation1& op1, const Operation2& op2)
+    {
+      return unary_compose<Operation1, Operation2>
+        ((typename unary_traits<Operation1>::param_type)op1, 
+         (typename unary_traits<Operation2>::param_type)op2);
+    }
+
+    template <class Operation1, class Operation2>
+    inline unary_compose<Operation1, Operation2>
+    compose1(Operation1& op1, Operation2& op2)
+    {
+      return unary_compose<Operation1, Operation2>(op1, op2);
+    }
+
+    // --------------------------------------------------------------------------
+    // binary_compose, compose2
+    // --------------------------------------------------------------------------
+    template <class Operation1, class Operation2, class Operation3>
+    class binary_compose
+        : public std::unary_function<typename unary_traits<Operation2>::argument_type,
+                                     typename binary_traits<Operation1>::result_type>
+    {
+      protected:
+        typename binary_traits<Operation1>::function_type op1;
+        typename unary_traits<Operation2>::function_type  op2;
+        typename unary_traits<Operation3>::function_type  op3;
+      public:
+        binary_compose(typename binary_traits<Operation1>::param_type x,
+                       typename unary_traits<Operation2>::param_type y,
+                       typename unary_traits<Operation3>::param_type z)
+            : 
+            op1(x), op2(y), op3(z)
+            {}
+
+        typename binary_traits<Operation1>::result_type
+        operator()(typename call_traits<typename unary_traits<Operation2>::argument_type>::param_type x) const
+        {
+            return op1(op2(x), op3(x));
+        }
+    };
+
+    template <class Operation1, class Operation2, class Operation3>
+    inline binary_compose<Operation1, Operation2, Operation3>
+    compose2(const Operation1& op1, const Operation2& op2, 
+             const Operation3& op3)
+    {
+        return binary_compose<Operation1, Operation2, Operation3>
+          ((typename binary_traits<Operation1>::param_type)op1,
+           (typename unary_traits<Operation2>::param_type)op2,
+           (typename unary_traits<Operation3>::param_type)op3);
+    }
+
+    template <class Operation1, class Operation2, class Operation3>
+    inline binary_compose<Operation1, Operation2, Operation3>
+    compose2(Operation1& op1, Operation2& op2, Operation3& op3)
+    {
+        return binary_compose<Operation1, Operation2, Operation3>(op1, op2, op3);
+    }
+
     // --------------------------------------------------------------------------
     // mem_fun, etc
     // --------------------------------------------------------------------------