diff --git a/bind.html b/bind.html
index 9c7b598..105ba94 100644
--- a/bind.html
+++ b/bind.html
@@ -761,7 +761,7 @@ namespace
(make_adaptable
helper function)
- libs/bind/bind_test.cpp
+ libs/bind/test/bind_test.cpp
(test)
libs/bind/bind_as_compose.cpp
@@ -770,16 +770,16 @@ namespace
libs/bind/bind_visitor.cpp
(visitor example)
- libs/bind/bind_stdcall_test.cpp
+ libs/bind/test/bind_stdcall_test.cpp
(test with __stdcall functions)
- libs/bind/bind_stdcall_mf_test.cpp
+ libs/bind/test/bind_stdcall_mf_test.cpp
(test with __stdcall member functions)
- libs/bind/bind_fastcall_test.cpp
+ libs/bind/test/bind_fastcall_test.cpp
(test with __fastcall functions)
- libs/bind/bind_fastcall_mf_test.cpp (test
+ libs/bind/test/bind_fastcall_mf_test.cpp (test
with __fastcall member functions)
diff --git a/mem_fn.html b/mem_fn.html
index 39a8f41..bc9dc81 100644
--- a/mem_fn.html
+++ b/mem_fn.html
@@ -1,9 +1,399 @@
+
-
-
-
-
-Automatic redirection failed, please go to
-../bind/mem_fn.html.
-
+
+ Boost: mem_fn.hpp documentation
+
+
+
+
+
+
+ 
+ |
+
+ mem_fn.hpp
+ |
+
+
+ | |
+
+
+ Contents
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ boost::mem_fn is a generalization of the standard functions std::mem_fun
+ and std::mem_fun_ref. It supports member function pointers with more
+ than one argument, and the returned function object can take a pointer, a
+ reference, or a smart pointer to an object instance as its first argument. mem_fn
+ also supports pointers to data members by treating them as functions taking no
+ arguments and returning a (const) reference to the member.
+
+
+ The purpose of mem_fn is twofold. First, it allows users to invoke a
+ member function on a container with the familiar
+
+
+ std::for_each(v.begin(), v.end(), boost::mem_fn(&Shape::draw));
+
+
+ syntax, even when the container stores smart pointers.
+
+
+ Second, it can be used as a building block by library developers that want to
+ treat a pointer to member function as a function object. A library might define
+ an enhanced for_each algorithm with an overload of the form:
+
+
+template<class It, class R, class T> void for_each(It first, It last, R (T::*pmf) ())
+{
+ std::for_each(first, last, boost::mem_fn(pmf));
+}
+
+
+ that will allow the convenient syntax:
+
+
+ for_each(v.begin(), v.end(), &Shape::draw);
+
+
+ When documenting the feature, the library author will simply state:
+
+ template<class It, class R, class T> void
+ for_each(It first, It last, R (T::*pmf) ());
+
+ Effects: equivalent to std::for_each(first, last, boost::mem_fn(pmf));
+
+
+ where boost::mem_fn can be a link to this page. See the
+ documentation of bind for an example.
+
+
+ mem_fn takes one argument, a pointer to a member, and returns a function
+ object suitable for use with standard or user-defined algorithms:
+
+
+struct X
+{
+ void f();
+};
+
+void g(std::vector<X> & v)
+{
+ std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
+};
+
+void h(std::vector<X *> const & v)
+{
+ std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
+};
+
+void k(std::vector<boost::shared_ptr<X> > const & v)
+{
+ std::for_each(v.begin(), v.end(), boost::mem_fn(&X::f));
+};
+
+
+ The returned function object takes the same arguments as the input member
+ function plus a "flexible" first argument that represents the object instance.
+
+
+ When the function object is invoked with a first argument x that is
+ neither a pointer nor a reference to the appropriate class (X in the
+ example above), it uses get_pointer(x) to obtain a pointer from x.
+ Library authors can "register" their smart pointer classes by supplying an
+ appropriate get_pointer overload, allowing mem_fn to recognize
+ and support them.
+
+
+ [Note: get_pointer is not restricted to return a pointer. Any object
+ that can be used in a member function call expression (x->*pmf)(...)
+ will work.]
+
+
+ [Note: the library uses an unqualified call to get_pointer. Therefore,
+ it will find, through argument-dependent lookup, get_pointer overloads
+ that are defined in the same namespace as the corresponding smart pointer
+ class, in addition to any boost::get_pointer overloads.]
+
+
+ All function objects returned by mem_fn expose a result_type typedef
+ that represents the return type of the member function. For data members, result_type
+ is defined as a const reference to the type of the member.
+
+
+
+
+ Yes. For simple uses, mem_fn provides additional functionality that the
+ standard adaptors do not. Complicated expressions that use std::bind1st, std::bind2nd
+ or Boost.Compose along with the
+ standard adaptors can be rewritten using boost::bind
+ that automatically takes advantage of mem_fn.
+
+
+
+ No, unless you have good reasons to do so. mem_fn is not 100% compatible
+ with the standard adaptors, although it comes pretty close. In particular, mem_fn
+ does not return objects of type std::[const_]mem_fun[1][_ref]_t, as the
+ standard adaptors do, and it is not possible to fully describe the type of the
+ first argument using the standard argument_type and first_argument_type
+ nested typedefs. Libraries that need adaptable function objects in order to
+ function might not like mem_fn.
+
+
+
+ Yes, if you #define BOOST_MEM_FN_ENABLE_STDCALL.
+
+
+
+ Non-portable extensions, in general, should default to off to prevent vendor
+ lock-in. Had BOOST_MEM_FN_ENABLE_STDCALL been defined automatically, you could
+ have accidentally taken advantage of it without realizing that your code is,
+ perhaps, no longer portable.
+
+
+
+
+namespace boost
+{
+
+template<class T> T * get_pointer(T * p);
+
+template<class R, class T> unspecified-1 mem_fn(R (T::*pmf) ());
+
+template<class R, class T> unspecified-2 mem_fn(R (T::*pmf) () const);
+
+template<class R, class T> unspecified-2-1 mem_fn(R T::*pm);
+
+template<class R, class T, class A1> unspecified-3 mem_fn(R (T::*pmf) (A1));
+
+template<class R, class T, class A1> unspecified-4 mem_fn(R (T::*pmf) (A1) const);
+
+template<class R, class T, class A1, class A2> unspecified-5 mem_fn(R (T::*pmf) (A1, A2));
+
+template<class R, class T, class A1, class A2> unspecified-6 mem_fn(R (T::*pmf) (A1, A2) const);
+
+// implementation defined number of additional overloads for more arguments
+
+}
+
+
+
+ All unspecified-N types mentioned in the Synopsis are CopyConstructible
+ and Assignable. Their copy constructors and assignment operators do not
+ throw exceptions. unspecified-N::result_type is defined as the
+ return type of the member function pointer passed as an argument to mem_fn
+ (R in the Synopsis.) unspecified-2-1::result_type is
+ defined as R const &.
+
+
+
+
+
+ Returns: p.
+
+
+ Throws: Nothing.
+
+
+
+
+
+
+ Returns: a function object f such that the expression f(t)
+ is equivalent to (t.*pmf)() when t is an l-value of type T
+ or derived, (get_pointer(t)->*pmf)() otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t)
+ is equivalent to (t.*pmf)() when t is of type T
+ [const] or derived, (get_pointer(t)->*pmf)()
+ otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t)
+ is equivalent to t.*pm when t is of type T [const]
+ or derived, get_pointer(t)->*pm otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t, a1)
+ is equivalent to (t.*pmf)(a1) when t is an l-value of type T
+ or derived, (get_pointer(t)->*pmf)(a1) otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t, a1)
+ is equivalent to (t.*pmf)(a1) when t is of type T
+ [const] or derived, (get_pointer(t)->*pmf)(a1)
+ otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t, a1, a2)
+ is equivalent to (t.*pmf)(a1, a2) when t is an l-value of type
+ T or derived, (get_pointer(t)->*pmf)(a1, a2) otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+ Returns: a function object f such that the expression f(t, a1, a2)
+ is equivalent to (t.*pmf)(a1, a2) when t is of type T
+ [const] or derived, (get_pointer(t)->*pmf)(a1, a2) otherwise.
+
+
+ Throws: Nothing.
+
+
+
+
+
+
+
+
+
+ This implementation supports member functions with up to eight arguments. This
+ is not an inherent limitation of the design, but an implementation detail.
+
+
+
+ Some platforms allow several types of member functions that differ by their calling
+ convention (the rules by which the function is invoked: how are
+ arguments passed, how is the return value handled, and who cleans up the stack
+ - if any.)
+
+
+ For example, Windows API functions and COM interface member functions use a
+ calling convention known as __stdcall. Borland VCL components use __fastcall.
+
+
+ To use mem_fn with __stdcall member functions, #define the
+ macro BOOST_MEM_FN_ENABLE_STDCALL before including, directly or
+ indirectly, <boost/mem_fn.hpp>.
+
+ To use mem_fn with __fastcall member functions, #define the
+ macro BOOST_MEM_FN_ENABLE_FASTCALL before including, directly or
+ indirectly, <boost/mem_fn.hpp>.
+
+ [Note: this is a non-portable extension. It is not part of the interface.]
+
+
+ [Note: Some compilers provide only minimal support for the __stdcall keyword.]
+
+
+
+ Rene Jager's initial suggestion of using traits classes to make mem_fn adapt
+ to user-defined smart pointers inspired the get_pointer-based design.
+
+
+ Numerous improvements were suggested during the formal review period by Richard
+ Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin Adler.
+
+
+ Steve Anichini pointed out that COM interfaces use __stdcall.
+
+
+ Dave Abrahams modified bind and mem_fn to support void returns on
+ deficient compilers.
+
+
+
+
+ Copyright © 2001, 2002 by Peter Dimov and Multi Media Ltd. Permission
+ to copy, use, modify, sell and distribute this document is granted provided
+ this copyright notice appears in all copies. This document is provided "as is"
+ without express or implied warranty, and with no claim as to its suitability
+ for any purpose.
+
diff --git a/test/Jamfile b/test/Jamfile
new file mode 100644
index 0000000..37d48eb
--- /dev/null
+++ b/test/Jamfile
@@ -0,0 +1,22 @@
+# Boost.Bind Library test Jamfile
+
+subproject libs/bind/test ;
+
+# bring in rules for testing
+SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
+include testing.jam ;
+
+# Make tests run by default.
+DEPENDS all : test ;
+
+{
+ # look in BOOST_ROOT for sources first, just in this Jamfile
+ local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
+
+ test-suite "bind"
+ : [ run libs/bind/test/bind_test.cpp ]
+ [ run libs/bind/test/mem_fn_test.cpp ]
+ [ run libs/bind/test/mem_fn_void_test.cpp ]
+ [ run libs/bind/test/mem_fn_derived_test.cpp ]
+ ;
+}
diff --git a/bind_fastcall_mf_test.cpp b/test/bind_fastcall_mf_test.cpp
similarity index 100%
rename from bind_fastcall_mf_test.cpp
rename to test/bind_fastcall_mf_test.cpp
diff --git a/bind_fastcall_test.cpp b/test/bind_fastcall_test.cpp
similarity index 100%
rename from bind_fastcall_test.cpp
rename to test/bind_fastcall_test.cpp
diff --git a/bind_stdcall_mf_test.cpp b/test/bind_stdcall_mf_test.cpp
similarity index 100%
rename from bind_stdcall_mf_test.cpp
rename to test/bind_stdcall_mf_test.cpp
diff --git a/bind_stdcall_test.cpp b/test/bind_stdcall_test.cpp
similarity index 100%
rename from bind_stdcall_test.cpp
rename to test/bind_stdcall_test.cpp
diff --git a/bind_test.cpp b/test/bind_test.cpp
similarity index 100%
rename from bind_test.cpp
rename to test/bind_test.cpp
diff --git a/mem_fn_derived_test.cpp b/test/mem_fn_derived_test.cpp
similarity index 100%
rename from mem_fn_derived_test.cpp
rename to test/mem_fn_derived_test.cpp
diff --git a/mem_fn_fastcall_test.cpp b/test/mem_fn_fastcall_test.cpp
similarity index 100%
rename from mem_fn_fastcall_test.cpp
rename to test/mem_fn_fastcall_test.cpp
diff --git a/mem_fn_stdcall_test.cpp b/test/mem_fn_stdcall_test.cpp
similarity index 100%
rename from mem_fn_stdcall_test.cpp
rename to test/mem_fn_stdcall_test.cpp
diff --git a/mem_fn_test.cpp b/test/mem_fn_test.cpp
similarity index 100%
rename from mem_fn_test.cpp
rename to test/mem_fn_test.cpp
diff --git a/mem_fn_void_test.cpp b/test/mem_fn_void_test.cpp
similarity index 100%
rename from mem_fn_void_test.cpp
rename to test/mem_fn_void_test.cpp