zeroc-ice 3.6b1

data/ext/ice/cpp/include/IceUtil/CountDownLatch.h

@@ -0,0 +1,50 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_COUNT_DOWN_LATCH_H
+#define ICE_UTIL_COUNT_DOWN_LATCH_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtilInternal
+{
+
+//
+// See java.util.concurrent.CountDownLatch in Java 1.5
+//
+
+class ICE_UTIL_API CountDownLatch
+{
+public:
+    
+    CountDownLatch(int);
+    ~CountDownLatch();
+
+    void await() const;
+    void countDown();
+    int getCount() const;
+   
+private:
+   
+#ifdef _WIN32
+    mutable LONG _count;
+    HANDLE _event;
+#else
+    int _count;
+    mutable pthread_mutex_t _mutex;
+    mutable pthread_cond_t _cond;
+
+    inline void lock() const;
+    inline void unlock() const;
+#endif
+};
+
+}
+
+#endif

data/ext/ice/cpp/include/IceUtil/CtrlCHandler.h

@@ -0,0 +1,70 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_CTRL_C_HANDLER_H
+#define ICE_UTIL_CTRL_C_HANDLER_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Exception.h>
+
+namespace IceUtil
+{
+
+// The CtrlCHandler provides a portable way to handle CTRL+C and
+// CTRL+C like signals 
+// On Unix/POSIX, the CtrlCHandler handles SIGHUP, SIGINT and SIGTERM. 
+// On Windows, it is essentially a wrapper for SetConsoleCtrlHandler().
+// 
+// In a process, only one CtrlCHandler can exist at a given time: 
+// the CtrlCHandler constructor raises CtrlCHandlerException if
+// you attempt to create a second CtrlCHandler.
+// On Unix/POSIX, it is essential to create the CtrlCHandler before
+// creating any thread, as the CtrlCHandler constructor masks (blocks)
+// SIGHUP, SIGINT and SIGTERM; by default, threads created later will 
+// inherit this signal mask.
+//
+// When a CTRL+C or CTRL+C like signal is sent to the process, the 
+// user-registered callback is called in a separate thread; it is 
+// given the signal number. The callback must not raise exceptions.
+// On Unix/POSIX, the callback is NOT a signal handler and can call 
+// functions that are not async-signal safe.
+//
+// The CtrCHandler destructor "unregisters" the callback. However
+// on Unix/POSIX it does not restore the old signal mask in any
+// thread, so SIGHUP, SIGINT and SIGTERM remain blocked.
+//
+// TODO: Maybe the behavior on Windows should be the same? Now we
+// just restore the default behavior (TerminateProcess).
+
+typedef void (*CtrlCHandlerCallback)(int);
+
+class ICE_UTIL_API CtrlCHandler
+{
+public:
+
+    CtrlCHandler(CtrlCHandlerCallback = 0);
+    ~CtrlCHandler();
+
+    void setCallback(CtrlCHandlerCallback);
+    CtrlCHandlerCallback getCallback() const;
+};
+
+class ICE_UTIL_API CtrlCHandlerException : public Exception
+{ 
+public:
+ 
+    CtrlCHandlerException(const char*, int);
+    virtual std::string ice_name() const;
+    virtual CtrlCHandlerException* ice_clone() const;
+    virtual void ice_throw() const;
+};
+
+}
+
+#endif

data/ext/ice/cpp/include/IceUtil/DisableWarnings.h

@@ -0,0 +1,45 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_DISABLEWARNINGS_H
+#define ICE_UTIL_DISABLEWARNINGS_H
+
+//
+// This header file disables or makes non-fatal various compiler warnings that
+// we don't want.
+//
+// IMPORTANT: Do *not* include this header file in another public header file!
+//            Doing this may potentially disable the warnings in the source
+//            code of our customers, which would be bad. Only include this
+//            header file in Ice *source* files!
+//
+
+//
+// Microsoft Visual C++
+//
+#if defined(_MSC_VER)
+#    define _CRT_SECURE_NO_DEPRECATE 1  // C4996 '<C function>' was declared deprecated
+#    pragma warning( 4 : 4996 ) // C4996 '<function>' was declared deprecated
+#    pragma warning( 4 : 4800 ) // C4800 forcing value to bool 'true' or 'false' (performance warning)
+
+#    if (_MSC_VER < 1700)
+#       pragma warning( 4 : 4355 ) // C4355 'this' : used in base member initializer list
+#    endif
+#endif
+
+
+//
+// GCC
+//
+#if defined(__GNUC__)
+#   pragma GCC diagnostic warning "-Wdeprecated-declarations"
+#endif
+
+
+#endif

data/ext/ice/cpp/include/IceUtil/Exception.h

@@ -0,0 +1,184 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_EXCEPTION_H
+#define ICE_UTIL_EXCEPTION_H
+
+#include <IceUtil/Config.h>
+
+#include <exception>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API Exception : public std::exception
+{
+public:
+
+    Exception();
+    Exception(const char*, int);
+
+    virtual ~Exception() throw();
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual const char* what() const throw();
+    virtual Exception* ice_clone() const;
+    virtual void ice_throw() const;
+
+    const char* ice_file() const;
+    int ice_line() const;
+    const std::string& ice_stackTrace() const;
+    
+private:
+    
+    const char* _file;
+    int _line;
+    static const char* _name;
+    const std::string _stackTrace;
+    mutable ::std::string _str; // Initialized lazily in what().
+};
+
+ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Exception&);
+
+class ICE_UTIL_API NullHandleException : public Exception
+{
+public:
+    
+    NullHandleException(const char*, int);
+    virtual ~NullHandleException() throw();
+    virtual std::string ice_name() const;
+    virtual NullHandleException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API IllegalArgumentException : public Exception
+{
+public:
+    
+    IllegalArgumentException(const char*, int);
+    IllegalArgumentException(const char*, int, const std::string&);
+    virtual ~IllegalArgumentException() throw();
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual IllegalArgumentException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    std::string reason() const;
+
+private:
+
+    static const char* _name;
+    const std::string _reason;
+};
+
+//
+// IllegalConversionException is raised to report a string conversion error 
+//
+class ICE_UTIL_API IllegalConversionException : public Exception
+{
+public:
+    
+    IllegalConversionException(const char*, int);
+    IllegalConversionException(const char*, int, const std::string&);
+    virtual ~IllegalConversionException() throw();
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual IllegalConversionException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    std::string reason() const;
+private:
+
+    static const char* _name;   
+    const std::string _reason;
+};
+
+
+class ICE_UTIL_API SyscallException : public Exception
+{
+public:
+
+    SyscallException(const char*, int, int);
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual SyscallException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    int error() const;
+
+private:
+
+    const int _error;
+    static const char* _name;
+};
+
+class ICE_UTIL_API FileLockException : public Exception
+{
+public:
+
+    FileLockException(const char*, int, int, const std::string&);
+    virtual ~FileLockException() throw();
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual FileLockException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    std::string path() const;
+    int error() const;
+
+private:
+
+    const int _error;
+    static const char* _name;
+    std::string _path;
+};
+
+class ICE_UTIL_API OptionalNotSetException : public Exception
+{
+public:
+    
+    OptionalNotSetException(const char*, int);
+    virtual ~OptionalNotSetException() throw();
+    virtual std::string ice_name() const;
+    virtual OptionalNotSetException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+#ifndef _WIN32
+class ICE_UTIL_API IconvInitializationException : public Exception
+{
+public:
+
+    IconvInitializationException(const char*, int, const std::string&);
+    virtual ~IconvInitializationException() throw();
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual IconvInitializationException* ice_clone() const;
+    virtual void ice_throw() const;
+
+    std::string reason() const;
+
+private:
+
+    static const char* _name;
+    std::string _reason;
+};
+#endif
+
+}
+
+#endif

data/ext/ice/cpp/include/IceUtil/Functional.h

@@ -0,0 +1,389 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#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);
+}
+
+}
+
+#endif
+