dos2unix

1 files changed, 453 insertions, 453 deletions

diff --git a/cpp/include/IceUtil/Functional.h b/cpp/include/IceUtil/Functional.h
index 57b0df17243..bf8b4ceac65 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