[boost] [bind] Patch that enables pass-by-value

15 Jun 2004

      Hi,
I'm a new user of this library, so not sure if this is a good idea or the best way to do this.

void f(int x)
{
        cout << "f(int): " << x << endl;
}

int x = 0;
bind(f, _1)(x);
//bind(f, _1)(1);  // Does not work.
bind(f, _1)(val<int>(1)); // But this does after patching.

This enables the user to pass-by-value if he specifies it explicitly, here is the patch:

Index: boost/bind.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/bind.hpp,v
retrieving revision 1.36
diff -u -c -d -r1.36 bind.hpp
*** boost/bind.hpp	8 Jun 2004 13:43:03 -0000	1.36
--- boost/bind.hpp	15 Jun 2004 19:13:43 -0000
***************
*** 27,32 ****
--- 27,33 ----
  #include <boost/type.hpp>
  #include <boost/bind/arg.hpp>
  #include <boost/detail/workaround.hpp>
+ #include <boost/val.hpp>

  // Borland-specific bug, visit_each() silently fails to produce code

Index: boost/bind/bind_template.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/bind/bind_template.hpp,v
retrieving revision 1.4
diff -u -c -d -r1.4 bind_template.hpp
*** boost/bind/bind_template.hpp	7 Mar 2004 16:39:15 -0000	1.4
--- boost/bind/bind_template.hpp	15 Jun 2004 19:13:43 -0000
***************
*** 27,32 ****
--- 27,38 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1> result_type operator()(val<A1> a1)
+     {
+         list1<A1> a(a1);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1> result_type operator()(A1 & a1)
      {
          list1<A1 &> a(a1);
***************
*** 39,44 ****
--- 45,56 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2> result_type operator()(val<A1> a1, val<A2> a2)
+     {
+         list2<A1, A2> a(a1, a2);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
      {
          list2<A1 &, A2 &> a(a1, a2);
***************
*** 51,56 ****
--- 63,74 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3)
+     {
+         list3<A1, A2, A3> a(a1, a2, a3);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
      {
          list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
***************
*** 63,68 ****
--- 81,92 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4)
+     {
+         list4<A1, A2, A3, A4> a(a1, a2, a3, a4);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
      {
          list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
***************
*** 75,80 ****
--- 99,110 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5)
+     {
+         list5<A1, A2, A3, A4, A5> a(a1, a2, a3, a4, a5);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
      {
          list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
***************
*** 87,92 ****
--- 117,128 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6)
+     {
+         list6<A1, A2, A3, A4, A5, A6> a(a1, a2, a3, a4, a5, a6);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
      {
          list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
***************
*** 99,104 ****
--- 135,146 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7)
+     {
+         list7<A1, A2, A3, A4, A5, A6, A7> a(a1, a2, a3, a4, a5, a6, a7);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
      {
          list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
***************
*** 111,116 ****
--- 153,164 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7, val<A8> a8)
+     {
+         list8<A1, A2, A3, A4, A5, A6, A7, A8> a(a1, a2, a3, a4, a5, a6, a7, a8);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
      {
          list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
***************
*** 123,128 ****
--- 171,182 ----
          BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
      }

+     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(val<A1> a1, val<A2> a2, val<A3> a3, val<A4> a4, val<A5> a5, val<A6> a6, val<A7> a7, val<A8> a8, val<A9> a9)
+     {
+         list9<A1, A2, A3, A4, A5, A6, A7, A8, A9> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+         BOOST_BIND_RETURN l_(type<result_type>(), f_, a, 0);
+     }
+ 
      template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
      {
          list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);

*** /dev/null	Thu Jan  1 01:00:00 1970
--- boost/val.hpp	Tue Jun 15 22:00:29 2004
***************
*** 0 ****
--- 1,35 ----
+ #ifndef BOOST_VAL_HPP_INCLUDED
+ #define BOOST_VAL_HPP_INCLUDED
+ 
+ //  val.hpp - Usefull helper functions
+ //
+ //  Copyright (C) 2004 Lars Rune Nøstdal (larsnostdal@organizer.net)
+ //
+ /*
+ 	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)
+ */
+ 
+ 
+ namespace boost {
+ 	
+ 	template<typename T>
+ 	struct val {
+ 		val(T t)
+ 			:value(t)
+ 		{
+ 		}
+ 		
+ 		operator T&()
+ 		{
+ 			return(value);
+ 		} 
+ 		
+ 	private:
+ 		T value;
+ 	}; // val
+ 	
+ } // namespace boost
+ 
+ #endif // #ifndef BOOST_VAL_HPP_INCLUDED

Thanks,
Lars Rune Nøstdal