more fixes

1 files changed, 33 insertions, 405 deletions

diff --git a/cpp/include/Ice/Functional.h b/cpp/include/Ice/Functional.h
index caf8ff06b93..3d972725efc 100644
--- a/cpp/include/Ice/Functional.h
+++ b/cpp/include/Ice/Functional.h
@@ -11,258 +11,8 @@
 #ifndef ICE_FUNCTIONAL_H
 #define ICE_FUNCTIONAL_H
 
+#include <IceUtil/Functional.h>
 #include <Ice/Handle.h>
-#include <functional>
-
-namespace IceInternal
-{
-
-// ----------------------------------------------------------------------
-// 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 p) const
-    {
-	return (p.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 h, A arg) const
-    {
-	return (p.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 p) const
-    {
-	(p.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 h, A arg) const
-    {
-	(p.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> p) const
-    {
-	return (p.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> h, A arg) const
-    {
-	return (p.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> p) const
-    {
-	(p.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> h, A arg) const
-    {
-	(p.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 p) const
-    {
-	return (p.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);
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstMemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(H h, A arg) const
-    {
-	return (p.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 p) const
-    {
-	(p.get() ->* _mfn)();
-    }
-};
-
-template<class T, class H, class A>
-class ConstVoidMemFun1 : public std::binary_function<H, A, void>
-{
-    typedef void (T::*MemberFN)(A);
-    MemberFN _mfn;
-
-public:
-
-    explicit ConstVoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(H h, A arg) const
-    {
-	(p.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> p) const
-    {
-	return (p.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);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstMemFun1(MemberFN p) : _mfn(p) { }
-    R operator()(std::pair<K, H> h, A arg) const
-    {
-	return (p.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> p) const
-    {
-	(p.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);
-    MemberFN _mfn;
-
-public:
-
-    explicit SecondConstVoidMemFun1(MemberFN p) : _mfn(p) { }
-    void operator()(std::pair<K, H> h, A arg) const
-    {
-	(p.second.get() ->* _mfn)(arg);
-    }
-};
-
-}
 
 // ----------------------------------------------------------------------
 // Inline functions that return function objects that work with
@@ -273,237 +23,115 @@ namespace IceInternal
 {
 
 template<class R, class T>
-inline ::IceInternal::MemFun<R, T, Handle<T> >
-memFun(R (T::*p)(void))
-{
-    return ::IceInternal::MemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceInternal::MemFun1<R, T, Handle<T>, A>
-memFun1(R (T::*p)(A))
-{
-    return ::IceInternal::MemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceInternal::VoidMemFun<T, Handle<T> >
-voidMemFun(void (T::*p)(void))
-{
-    return ::IceInternal::VoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceInternal::VoidMemFun1<T, Handle<T>, A>
-voidMemFun1(void (T::*p)(A))
-{
-    return ::IceInternal::VoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceInternal::SecondMemFun<R, K, T, Handle<T> >
-secondMemFun(R (T::*p)(void))
-{
-    return ::IceInternal::SecondMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceInternal::SecondMemFun1<R, K, T, Handle<T>, A>
-secondMemFun1(R (T::*p)(A))
-{
-    return ::IceInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceInternal::SecondVoidMemFun<K, T, Handle<T> >
-secondVoidMemFun(void (T::*p)(void))
-{
-    return ::IceInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
-secondVoidMemFun1(void (T::*p)(A))
-{
-    return ::IceInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-template<class R, class T>
-inline ::IceInternal::ConstMemFun<R, T, Handle<T> >
-constMemFun(R (T::*p)(void) const)
-{
-    return ::IceInternal::ConstMemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceInternal::ConstMemFun1<R, T, Handle<T>, A>
-constMemFun1(R (T::*p)(A))
-{
-    return ::IceInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceInternal::ConstVoidMemFun<T, Handle<T> >
-constVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceInternal::ConstVoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceInternal::ConstVoidMemFun1<T, Handle<T>, A>
-constVoidMemFun1(void (T::*p)(A))
-{
-    return ::IceInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceInternal::SecondConstMemFun<R, K, T, Handle<T> >
-secondConstMemFun(R (T::*p)(void) const)
-{
-    return ::IceInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
-secondConstMemFun1(R (T::*p)(A))
-{
-    return ::IceInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceInternal::SecondConstVoidMemFun<K, T, Handle<T> >
-secondConstVoidMemFun(void (T::*p)(void) const)
-{
-    return ::IceInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
-secondConstVoidMemFun1(void (T::*p)(A))
-{
-    return ::IceInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-}
-
-// ----------------------------------------------------------------------
-// Inline functions that return function objects that work with
-// Ice::Handle
-// ----------------------------------------------------------------------
-
-namespace Ice
-{
-
-template<class R, class T>
-inline ::IceInternal::MemFun<R, T, Handle<T> >
+inline ::IceUtilInternal::MemFun<R, T, Handle<T> >
 memFun(R (T::*p)(void))
 {
-    return ::IceInternal::MemFun<R, T, Handle<T> >(p);
+    return ::IceUtilInternal::MemFun<R, T, Handle<T> >(p);
 }
 
 template<class R, class T, class A>
-inline ::IceInternal::MemFun1<R, T, Handle<T>, A>
+inline ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>
 memFun1(R (T::*p)(A))
 {
-    return ::IceInternal::MemFun1<R, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>(p);
 }
 
 template<class T>
-inline ::IceInternal::VoidMemFun<T, Handle<T> >
+inline ::IceUtilInternal::VoidMemFun<T, Handle<T> >
 voidMemFun(void (T::*p)(void))
 {
-    return ::IceInternal::VoidMemFun<T, Handle<T> >(p);
+    return ::IceUtilInternal::VoidMemFun<T, Handle<T> >(p);
 }
 
 template<class T, class A>
-inline ::IceInternal::VoidMemFun1<T, Handle<T>, A>
+inline ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>
 voidMemFun1(void (T::*p)(A))
 {
-    return ::IceInternal::VoidMemFun1<T, Handle<T>, A>(p);
+    return ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>(p);
 }
 
 template<class R, class K, class T>
-inline ::IceInternal::SecondMemFun<R, K, T, Handle<T> >
+inline ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >
 secondMemFun(R (T::*p)(void))
 {
-    return ::IceInternal::SecondMemFun<R, K, T, Handle<T> >(p);
+    return ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >(p);
 }
 
 template<class R, class K, class T, class A>
-inline ::IceInternal::SecondMemFun1<R, K, T, Handle<T>, A>
+inline ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>
 secondMemFun1(R (T::*p)(A))
 {
-    return ::IceInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
 }
 
 template<class K, class T>
-inline ::IceInternal::SecondVoidMemFun<K, T, Handle<T> >
+inline ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >
 secondVoidMemFun(void (T::*p)(void))
 {
-    return ::IceInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
+    return ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
 }
 
 template<class K, class T, class A>
-inline ::IceInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
+inline ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
 secondVoidMemFun1(void (T::*p)(A))
 {
-    return ::IceInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
 }
 
 template<class R, class T>
-inline ::IceInternal::ConstMemFun<R, T, Handle<T> >
+inline ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >
 constMemFun(R (T::*p)(void) const)
 {
-    return ::IceInternal::ConstMemFun<R, T, Handle<T> >(p);
+    return ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >(p);
 }
 
 template<class R, class T, class A>
-inline ::IceInternal::ConstMemFun1<R, T, Handle<T>, A>
+inline ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>
 constMemFun1(R (T::*p)(A))
 {
-    return ::IceInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
 }
 
 template<class T>
-inline ::IceInternal::ConstVoidMemFun<T, Handle<T> >
+inline ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >
 constVoidMemFun(void (T::*p)(void) const)
 {
-    return ::IceInternal::ConstVoidMemFun<T, Handle<T> >(p);
+    return ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >(p);
 }
 
 template<class T, class A>
-inline ::IceInternal::ConstVoidMemFun1<T, Handle<T>, A>
+inline ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>
 constVoidMemFun1(void (T::*p)(A))
 {
-    return ::IceInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
+    return ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
 }
 
 template<class R, class K, class T>
-inline ::IceInternal::SecondConstMemFun<R, K, T, Handle<T> >
+inline ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >
 secondConstMemFun(R (T::*p)(void) const)
 {
-    return ::IceInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
+    return ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
 }
 
 template<class R, class K, class T, class A>
-inline ::IceInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
+inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
 secondConstMemFun1(R (T::*p)(A))
 {
-    return ::IceInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
 }
 
 template<class K, class T>
-inline ::IceInternal::SecondConstVoidMemFun<K, T, Handle<T> >
+inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >
 secondConstVoidMemFun(void (T::*p)(void) const)
 {
-    return ::IceInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
+    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
 }
 
 template<class K, class T, class A>
-inline ::IceInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
+inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
 secondConstVoidMemFun1(void (T::*p)(A))
 {
-    return ::IceInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
 }
 
 }