first commit

extern/STLport/5.2.1/test/unit/fadapter.h

@@ -0,0 +1,80 @@
+#ifndef _fadapter_h_
+#define _fadapter_h_
+
+#include <functional>
+
+// used as adaptor's return/argument type,
+// to allow binders/composers usage
+struct __void_tag {};
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using std::unary_function;
+#endif
+
+template <class Result>
+class pointer_to_void_function {
+protected:
+  Result (*ptr)();
+public:
+  explicit pointer_to_void_function(Result (*x)()) : ptr(x) {}
+  Result operator()() const { return ptr(); }
+  Result operator()(__void_tag) const { return ptr(); }
+};
+
+// to feed composers
+template <class Arg1>
+struct projectvoid : public unary_function<Arg1,__void_tag> {
+  __void_tag operator()(const Arg1& x) const { return __void_tag(); }
+};
+
+#if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
+
+template <class Result>
+pointer_to_void_function<Result> ptr_fun(Result (*x)()) {
+  return pointer_to_void_function<Result>(x);
+}
+
+// alternate name
+template <class Result>
+pointer_to_void_function<Result> ptr_gen(Result (*x)()) {
+  return pointer_to_void_function<Result>(x);
+}
+
+#endif /*  !defined (_STLP_MEMBER_POINTER_PARAM_BUG) */
+
+template <class Arg>
+class pointer_to_unary_procedure /* :public unary_function<Arg, __void_tag> */ {
+protected:
+  typedef void (*fun_type)(Arg);
+  fun_type ptr;
+public:
+  typedef Arg argument_type;
+  pointer_to_unary_procedure() {}
+  pointer_to_unary_procedure(fun_type x) : ptr(x) {}
+  void operator() (Arg x) const { ptr(x); }
+};
+
+template <class Arg>
+inline pointer_to_unary_procedure<Arg> ptr_proc(void (*x)(Arg)) {
+  return pointer_to_unary_procedure<Arg>(x);
+}
+
+template <class Arg1, class Arg2>
+class pointer_to_binary_procedure /* : public unary_function<Arg1, Arg2, __void_tag> */ {
+protected:
+  typedef void (*fun_type)(Arg1, Arg2);
+  fun_type ptr;
+public:
+  typedef Arg1 first_argument_type;
+  typedef Arg2 second_argument_type;
+  pointer_to_binary_procedure() {}
+  pointer_to_binary_procedure(fun_type x) : ptr(x) {}
+  void operator() (Arg1 x, Arg2 y) const { ptr(x, y); }
+};
+
+template <class Arg1, class Arg2>
+inline pointer_to_binary_procedure<Arg1, Arg2> ptr_proc(void (*x)(Arg1, Arg2)) {
+  return pointer_to_binary_procedure<Arg1, Arg2>(x);
+}
+
+#endif