thread fixes

1 files changed, 453 insertions, 453 deletions

diff --git a/cpp/include/IceUtil/Functional.h b/cpp/include/IceUtil/Functional.h
index bf8b4ceac65..57b0df17243 100644
--- a/cpp/include/IceUtil/Functional.h
+++ b/cpp/include/IceUtil/Functional.h
@@ -1,453 +1,453 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_FUNCTIONAL_H
-#define ICE_UTIL_FUNCTIONAL_H
-
-#include <IceUtil/Handle.h>
-#include <functional>
-
-namespace IceUtilInternal
-{
-
-// ----------------------------------------------------------------------
-// Various function objects that work with handles instead of plain
-// pointers.
-// ----------------------------------------------------------------------
-
-template<class R, class T, class H>
-class MemFun : public std::unary_function<H, R>
-{
-    typedef R (T::*MemberFN)(void);
-    MemberFN _mfn;
-
-public:
-
-    explicit MemFun(MemberFN p) : _mfn(p) { }
-    R operator()(H handle) const
-    {
-	return (handle.get() ->* _mfn)();
-    }
-};
-
-template<class R, class T, class H, class A>
-class MemFun1 : public std::binary_function<H, A, R>
-{
-    typedef R (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit MemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(H handle, A arg) const
-    {
-	return (handle.get() ->* _mfn)(arg);
-    }
-};
-
-template<class T, class H>
-class VoidMemFun : public std::unary_function<H, void>
-{
-    typedef void (T::*MemberFN)(void);
-    MemberFN _mfn;
-
-public:
-
-    explicit VoidMemFun(MemberFN p) : _mfn(p) { }
-    void operator()(H handle) const
-    {
-	(handle.get() ->* _mfn)();
-    }
-};
-
-template<class T, class H, class A>
-class VoidMemFun1 : public std::binary_function<H, A, void>
-{
-    typedef void (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit VoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(H handle, A arg) const
-    {
-	(handle.get() ->* _mfn)(arg);
-    }
-};
-
-template<class R, class K, class T, class H>
-class SecondMemFun : public std::unary_function<std::pair<K, H>, R>
-{
-    typedef R (T::*MemberFN)(void);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondMemFun(MemberFN p) : _mfn(p) { }
-    R operator()(std::pair<K, H> pair) const
-    {
-	return (pair.second.get() ->* _mfn)();
-    }
-};
-
-template<class R, class K, class T, class H, class A>
-class SecondMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
-{
-    typedef R (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondMemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(std::pair<K, H> pair, A arg) const
-    {
-	return (pair.second.get() ->* _mfn)(arg);
-    }
-};
-
-template<class K, class T, class H>
-class SecondVoidMemFun : public std::unary_function<std::pair<K, H>, void>
-{
-    typedef void (T::*MemberFN)(void);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondVoidMemFun(MemberFN p) : _mfn(p) { }
-    void operator()(std::pair<K, H> pair) const
-    {
-	(pair.second.get() ->* _mfn)();
-    }
-};
-
-template<class K, class T, class H, class A>
-class SecondVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
-{
-    typedef void (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondVoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(std::pair<K, H> pair, A arg) const
-    {
-	(pair.second.get() ->* _mfn)(arg);
-    }
-};
-
-template<class R, class T, class H>
-class ConstMemFun : public std::unary_function<H, R>
-{
-    typedef R (T::*MemberFN)(void) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstMemFun(MemberFN p) : _mfn(p) { }
-    R operator()(H handle) const
-    {
-	return (handle.get() ->* _mfn)();
-    }
-};
-
-template<class R, class T, class H, class A>
-class ConstMemFun1 : public std::binary_function<H, A, R>
-{
-    typedef R (T::*MemberFN)(A) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstMemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(H handle, A arg) const
-    {
-	return (handle.get() ->* _mfn)(arg);
-    }
-};
-
-template<class T, class H>
-class ConstVoidMemFun : public std::unary_function<H, void>
-{
-    typedef void (T::*MemberFN)(void) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstVoidMemFun(MemberFN p) : _mfn(p) { }
-    void operator()(H handle) const
-    {
-	(handle.get() ->* _mfn)();
-    }
-};
-
-template<class T, class H, class A>
-class ConstVoidMemFun1 : public std::binary_function<H, A, void>
-{
-    typedef void (T::*MemberFN)(A) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstVoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(H handle, A arg) const
-    {
-	(handle.get() ->* _mfn)(arg);
-    }
-};
-
-template<class R, class K, class T, class H>
-class SecondConstMemFun : public std::unary_function<std::pair<K, H>, R>
-{
-    typedef R (T::*MemberFN)(void) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstMemFun(MemberFN p) : _mfn(p) { }
-    R operator()(std::pair<K, H> pair) const
-    {
-	return (pair.second.get() ->* _mfn)();
-    }
-};
-
-template<class R, class K, class T, class H, class A>
-class SecondConstMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
-{
-    typedef R (T::*MemberFN)(A) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstMemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(std::pair<K, H> pair, A arg) const
-    {
-	return (pair.second.get() ->* _mfn)(arg);
-    }
-};
-
-template<class K, class T, class H>
-class SecondConstVoidMemFun : public std::unary_function<std::pair<K, H>, void>
-{
-    typedef void (T::*MemberFN)(void) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstVoidMemFun(MemberFN p) : _mfn(p) { }
-    void operator()(std::pair<K, H> pair) const
-    {
-	(pair.second.get() ->* _mfn)();
-    }
-};
-
-template<class K, class T, class H, class A>
-class SecondConstVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
-{
-    typedef void (T::*MemberFN)(A) const;
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstVoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(std::pair<K, H> pair, A arg) const
-    {
-	(pair.second.get() ->* _mfn)(arg);
-    }
-};
-
-}
-
-// ----------------------------------------------------------------------
-// Inline functions that return function objects that work with
-// IceUtil::Handle
-// ----------------------------------------------------------------------
-
-namespace IceUtil
-{
-
-template<class R, class T>
-inline ::IceUtilInternal::MemFun<R, T, Handle<T> >
-memFun(R (T::*p)(void))
-{
-    return ::IceUtilInternal::MemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>
-memFun1(R (T::*p)(A))
-{
-    return ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::VoidMemFun<T, Handle<T> >
-voidMemFun(void (T::*p)(void))
-{
-    return ::IceUtilInternal::VoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>
-voidMemFun1(void (T::*p)(A))
-{
-    return ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >
-secondMemFun(R (T::*p)(void))
-{
-    return ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>
-secondMemFun1(R (T::*p)(A))
-{
-    return ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >
-secondVoidMemFun(void (T::*p)(void))
-{
-    return ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
-secondVoidMemFun1(void (T::*p)(A))
-{
-    return ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-template<class R, class T>
-inline ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >
-constMemFun(R (T::*p)(void) const)
-{
-    return ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>
-constMemFun1(R (T::*p)(A) const)
-{
-    return ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >
-constVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>
-constVoidMemFun1(void (T::*p)(A) const)
-{
-    return ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >
-secondConstMemFun(R (T::*p)(void) const)
-{
-    return ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
-secondConstMemFun1(R (T::*p)(A) const)
-{
-    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >
-secondConstVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
-secondConstVoidMemFun1(void (T::*p)(A) const)
-{
-    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-}
-
-// ----------------------------------------------------------------------
-// Extension for STLport: Special versions for bind1st and bind2nd for
-// operations that do not return anything (i.e., return void). Needed
-// for broken compilers, such as Visual C++
-// ----------------------------------------------------------------------
-
-#ifdef _STLP_BEGIN_NAMESPACE
-
-_STLP_BEGIN_NAMESPACE
-
-template <class _Operation> 
-class voidbinder1st : 
-    public unary_function<typename __BINARY_ARG(_Operation,second_argument_type),
-                          typename __BINARY_ARG(_Operation,result_type) > {
-protected:
-  _Operation _M_op;
-  typename _Operation::first_argument_type _M_value;
-public:
-  voidbinder1st(const _Operation& __x,
-            const typename _Operation::first_argument_type& __y)
-      : _M_op(__x), _M_value(__y) {}
-  typename _Operation::result_type
-  operator()(const typename _Operation::second_argument_type& __x) const {
-    _M_op(_M_value, __x); 
-  }
-};
-
-template <class _Operation, class _Tp>
-inline voidbinder1st<_Operation> 
-voidbind1st(const _Operation& __fn, const _Tp& __x) 
-{
-  typedef typename _Operation::first_argument_type _Arg1_type;
-  return voidbinder1st<_Operation>(__fn, _Arg1_type(__x));
-}
-
-template <class _Operation> 
-class voidbinder2nd
-  : public unary_function<typename __BINARY_ARG(_Operation,first_argument_type),
-                          typename __BINARY_ARG(_Operation,result_type)> {
-protected:
-  _Operation _M_op;
-  typename _Operation::second_argument_type value;
-public:
-  voidbinder2nd(const _Operation& __x,
-            const typename _Operation::second_argument_type& __y) 
-      : _M_op(__x), value(__y) {}
-  typename _Operation::result_type
-  operator()(const typename _Operation::first_argument_type& __x) const {
-    _M_op(__x, value); 
-  }
-};
-
-template <class _Operation, class _Tp>
-inline voidbinder2nd<_Operation> 
-voidbind2nd(const _Operation& __fn, const _Tp& __x) 
-{
-  typedef typename _Operation::second_argument_type _Arg2_type;
-  return voidbinder2nd<_Operation>(__fn, _Arg2_type(__x));
-}
-
-_STLP_END_NAMESPACE
-
-#endif
-
-#endif
+// **********************************************************************

+//

+// Copyright (c) 2001

+// Mutable Realms, Inc.

+// Huntsville, AL, USA

+//

+// All Rights Reserved

+//

+// **********************************************************************

+

+#ifndef ICE_UTIL_FUNCTIONAL_H

+#define ICE_UTIL_FUNCTIONAL_H

+

+#include <IceUtil/Handle.h>

+#include <functional>

+

+namespace IceUtilInternal

+{

+

+// ----------------------------------------------------------------------

+// Various function objects that work with handles instead of plain

+// pointers.

+// ----------------------------------------------------------------------

+

+template<class R, class T, class H>

+class MemFun : public std::unary_function<H, R>

+{

+    typedef R (T::*MemberFN)(void);

+    MemberFN _mfn;

+

+public:

+

+    explicit MemFun(MemberFN p) : _mfn(p) { }

+    R operator()(H handle) const

+    {

+	return (handle.get() ->* _mfn)();

+    }

+};

+

+template<class R, class T, class H, class A>

+class MemFun1 : public std::binary_function<H, A, R>

+{

+    typedef R (T::*MemberFN)(A);

+    MemberFN _mfn;

+

+public:

+

+    explicit MemFun1(MemberFN p) : _mfn(p) { }

+    R operator()(H handle, A arg) const

+    {

+	return (handle.get() ->* _mfn)(arg);

+    }

+};

+

+template<class T, class H>

+class VoidMemFun : public std::unary_function<H, void>

+{

+    typedef void (T::*MemberFN)(void);

+    MemberFN _mfn;

+

+public:

+

+    explicit VoidMemFun(MemberFN p) : _mfn(p) { }

+    void operator()(H handle) const

+    {

+	(handle.get() ->* _mfn)();

+    }

+};

+

+template<class T, class H, class A>

+class VoidMemFun1 : public std::binary_function<H, A, void>

+{

+    typedef void (T::*MemberFN)(A);

+    MemberFN _mfn;

+

+public:

+

+    explicit VoidMemFun1(MemberFN p) : _mfn(p) { }

+    void operator()(H handle, A arg) const

+    {

+	(handle.get() ->* _mfn)(arg);

+    }

+};

+

+template<class R, class K, class T, class H>

+class SecondMemFun : public std::unary_function<std::pair<K, H>, R>

+{

+    typedef R (T::*MemberFN)(void);

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondMemFun(MemberFN p) : _mfn(p) { }

+    R operator()(std::pair<K, H> pair) const

+    {

+	return (pair.second.get() ->* _mfn)();

+    }

+};

+

+template<class R, class K, class T, class H, class A>

+class SecondMemFun1 : public std::binary_function<std::pair<K, H>, A, R>

+{

+    typedef R (T::*MemberFN)(A);

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondMemFun1(MemberFN p) : _mfn(p) { }

+    R operator()(std::pair<K, H> pair, A arg) const

+    {

+	return (pair.second.get() ->* _mfn)(arg);

+    }

+};

+

+template<class K, class T, class H>

+class SecondVoidMemFun : public std::unary_function<std::pair<K, H>, void>

+{

+    typedef void (T::*MemberFN)(void);

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondVoidMemFun(MemberFN p) : _mfn(p) { }

+    void operator()(std::pair<K, H> pair) const

+    {

+	(pair.second.get() ->* _mfn)();

+    }

+};

+

+template<class K, class T, class H, class A>

+class SecondVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>

+{

+    typedef void (T::*MemberFN)(A);

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondVoidMemFun1(MemberFN p) : _mfn(p) { }

+    void operator()(std::pair<K, H> pair, A arg) const

+    {

+	(pair.second.get() ->* _mfn)(arg);

+    }

+};

+

+template<class R, class T, class H>

+class ConstMemFun : public std::unary_function<H, R>

+{

+    typedef R (T::*MemberFN)(void) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit ConstMemFun(MemberFN p) : _mfn(p) { }

+    R operator()(H handle) const

+    {

+	return (handle.get() ->* _mfn)();

+    }

+};

+

+template<class R, class T, class H, class A>

+class ConstMemFun1 : public std::binary_function<H, A, R>

+{

+    typedef R (T::*MemberFN)(A) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit ConstMemFun1(MemberFN p) : _mfn(p) { }

+    R operator()(H handle, A arg) const

+    {

+	return (handle.get() ->* _mfn)(arg);

+    }

+};

+

+template<class T, class H>

+class ConstVoidMemFun : public std::unary_function<H, void>

+{

+    typedef void (T::*MemberFN)(void) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit ConstVoidMemFun(MemberFN p) : _mfn(p) { }

+    void operator()(H handle) const

+    {

+	(handle.get() ->* _mfn)();

+    }

+};

+

+template<class T, class H, class A>

+class ConstVoidMemFun1 : public std::binary_function<H, A, void>

+{

+    typedef void (T::*MemberFN)(A) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit ConstVoidMemFun1(MemberFN p) : _mfn(p) { }

+    void operator()(H handle, A arg) const

+    {

+	(handle.get() ->* _mfn)(arg);

+    }

+};

+

+template<class R, class K, class T, class H>

+class SecondConstMemFun : public std::unary_function<std::pair<K, H>, R>

+{

+    typedef R (T::*MemberFN)(void) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondConstMemFun(MemberFN p) : _mfn(p) { }

+    R operator()(std::pair<K, H> pair) const

+    {

+	return (pair.second.get() ->* _mfn)();

+    }

+};

+

+template<class R, class K, class T, class H, class A>

+class SecondConstMemFun1 : public std::binary_function<std::pair<K, H>, A, R>

+{

+    typedef R (T::*MemberFN)(A) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondConstMemFun1(MemberFN p) : _mfn(p) { }

+    R operator()(std::pair<K, H> pair, A arg) const

+    {

+	return (pair.second.get() ->* _mfn)(arg);

+    }

+};

+

+template<class K, class T, class H>

+class SecondConstVoidMemFun : public std::unary_function<std::pair<K, H>, void>

+{

+    typedef void (T::*MemberFN)(void) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondConstVoidMemFun(MemberFN p) : _mfn(p) { }

+    void operator()(std::pair<K, H> pair) const

+    {

+	(pair.second.get() ->* _mfn)();

+    }

+};

+

+template<class K, class T, class H, class A>

+class SecondConstVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>

+{

+    typedef void (T::*MemberFN)(A) const;

+    MemberFN _mfn;

+

+public:

+

+    explicit SecondConstVoidMemFun1(MemberFN p) : _mfn(p) { }

+    void operator()(std::pair<K, H> pair, A arg) const

+    {

+	(pair.second.get() ->* _mfn)(arg);

+    }

+};

+

+}

+

+// ----------------------------------------------------------------------

+// Inline functions that return function objects that work with

+// IceUtil::Handle

+// ----------------------------------------------------------------------

+

+namespace IceUtil

+{

+

+template<class R, class T>

+inline ::IceUtilInternal::MemFun<R, T, Handle<T> >

+memFun(R (T::*p)(void))

+{

+    return ::IceUtilInternal::MemFun<R, T, Handle<T> >(p);

+}

+

+template<class R, class T, class A>

+inline ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>

+memFun1(R (T::*p)(A))

+{

+    return ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>(p);

+}

+

+template<class T>

+inline ::IceUtilInternal::VoidMemFun<T, Handle<T> >

+voidMemFun(void (T::*p)(void))

+{

+    return ::IceUtilInternal::VoidMemFun<T, Handle<T> >(p);

+}

+

+template<class T, class A>

+inline ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>

+voidMemFun1(void (T::*p)(A))

+{

+    return ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>(p);

+}

+

+template<class R, class K, class T>

+inline ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >

+secondMemFun(R (T::*p)(void))

+{

+    return ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >(p);

+}

+

+template<class R, class K, class T, class A>

+inline ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>

+secondMemFun1(R (T::*p)(A))

+{

+    return ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);

+}

+

+template<class K, class T>

+inline ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >

+secondVoidMemFun(void (T::*p)(void))

+{

+    return ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >(p);

+}

+

+template<class K, class T, class A>

+inline ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>

+secondVoidMemFun1(void (T::*p)(A))

+{

+    return ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);

+}

+

+template<class R, class T>

+inline ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >

+constMemFun(R (T::*p)(void) const)

+{

+    return ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >(p);

+}

+

+template<class R, class T, class A>

+inline ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>

+constMemFun1(R (T::*p)(A) const)

+{

+    return ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>(p);

+}

+

+template<class T>

+inline ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >

+constVoidMemFun(void (T::*p)(void) const)

+{

+    return ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >(p);

+}

+

+template<class T, class A>

+inline ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>

+constVoidMemFun1(void (T::*p)(A) const)

+{

+    return ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);

+}

+

+template<class R, class K, class T>

+inline ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >

+secondConstMemFun(R (T::*p)(void) const)

+{

+    return ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);

+}

+

+template<class R, class K, class T, class A>

+inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>

+secondConstMemFun1(R (T::*p)(A) const)

+{

+    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);

+}

+

+template<class K, class T>

+inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >

+secondConstVoidMemFun(void (T::*p)(void) const)

+{

+    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);

+}

+

+template<class K, class T, class A>

+inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>

+secondConstVoidMemFun1(void (T::*p)(A) const)

+{

+    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);

+}

+

+}

+

+// ----------------------------------------------------------------------

+// Extension for STLport: Special versions for bind1st and bind2nd for

+// operations that do not return anything (i.e., return void). Needed

+// for broken compilers, such as Visual C++

+// ----------------------------------------------------------------------

+

+#ifdef _STLP_BEGIN_NAMESPACE

+

+_STLP_BEGIN_NAMESPACE

+

+template <class _Operation> 

+class voidbinder1st : 

+    public unary_function<typename __BINARY_ARG(_Operation,second_argument_type),

+                          typename __BINARY_ARG(_Operation,result_type) > {

+protected:

+  _Operation _M_op;

+  typename _Operation::first_argument_type _M_value;

+public:

+  voidbinder1st(const _Operation& __x,

+            const typename _Operation::first_argument_type& __y)

+      : _M_op(__x), _M_value(__y) {}

+  typename _Operation::result_type

+  operator()(const typename _Operation::second_argument_type& __x) const {

+    _M_op(_M_value, __x); 

+  }

+};

+

+template <class _Operation, class _Tp>

+inline voidbinder1st<_Operation> 

+voidbind1st(const _Operation& __fn, const _Tp& __x) 

+{

+  typedef typename _Operation::first_argument_type _Arg1_type;

+  return voidbinder1st<_Operation>(__fn, _Arg1_type(__x));

+}

+

+template <class _Operation> 

+class voidbinder2nd

+  : public unary_function<typename __BINARY_ARG(_Operation,first_argument_type),

+                          typename __BINARY_ARG(_Operation,result_type)> {

+protected:

+  _Operation _M_op;

+  typename _Operation::second_argument_type value;

+public:

+  voidbinder2nd(const _Operation& __x,

+            const typename _Operation::second_argument_type& __y) 

+      : _M_op(__x), value(__y) {}

+  typename _Operation::result_type

+  operator()(const typename _Operation::first_argument_type& __x) const {

+    _M_op(__x, value); 

+  }

+};

+

+template <class _Operation, class _Tp>

+inline voidbinder2nd<_Operation> 

+voidbind2nd(const _Operation& __fn, const _Tp& __x) 

+{

+  typedef typename _Operation::second_argument_type _Arg2_type;

+  return voidbinder2nd<_Operation>(__fn, _Arg2_type(__x));

+}

+

+_STLP_END_NAMESPACE

+

+#endif

+

+#endif