zeroc-ice 3.6.5 → 3.7.4

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

@@ -0,0 +1,92 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_CONSOLE_UTIL_H
+#define ICE_UTIL_CONSOLE_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/StringConverter.h>
+#include <iostream>
+
+namespace IceUtilInternal
+{
+
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
+
+class ConsoleUtil;
+ICE_DEFINE_PTR(ConsoleUtilPtr, ConsoleUtil);
+
+class ICE_API ConsoleUtil
+#  ifndef ICE_CPP11_MAPPING
+    : public IceUtil::Shared
+#  endif
+{
+public:
+
+    ConsoleUtil();
+    void output(const std::string&) const;
+    void error(const std::string&) const;
+
+private:
+
+    std::string toConsoleEncoding(const std::string&) const;
+    IceUtil::StringConverterPtr _converter;
+    IceUtil::StringConverterPtr _consoleConverter;
+};
+
+const ICE_API ConsoleUtil& getConsoleUtil();
+
+class ICE_API ConsoleOut
+{
+public:
+
+    ConsoleOut& operator<<(ConsoleOut& (*pf)(ConsoleOut&));
+};
+
+class ICE_API ConsoleErr
+{
+public:
+
+    ConsoleErr& operator<<(ConsoleErr& (*pf)(ConsoleErr&));
+};
+
+template<typename T>
+ConsoleOut&
+operator<<(ConsoleOut& out, const T& val)
+{
+    std::ostringstream s;
+    s << val;
+    getConsoleUtil().output(s.str());
+    return out;
+}
+
+ICE_API ConsoleOut& endl(ConsoleOut&);
+ICE_API ConsoleOut& flush(ConsoleOut&);
+
+template<typename T>
+ConsoleErr&
+operator<<(ConsoleErr& err, const T& val)
+{
+    std::ostringstream s;
+    s << val;
+    getConsoleUtil().error(s.str());
+    return err;
+}
+
+ICE_API ConsoleErr& endl(ConsoleErr&);
+ICE_API ConsoleErr& flush(ConsoleErr&);
+
+extern ICE_API ConsoleOut consoleOut ICE_GLOBAL_VAR_SUFFIX;
+extern ICE_API ConsoleErr consoleErr ICE_GLOBAL_VAR_SUFFIX;
+
+#else
+
+extern ICE_API std::ostream& consoleOut ICE_GLOBAL_VAR_SUFFIX;
+extern ICE_API std::ostream& consoleErr ICE_GLOBAL_VAR_SUFFIX;
+
+#endif
+
+}
+
+#endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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
@@ -19,19 +14,19 @@ namespace IceUtilInternal
 // See java.util.concurrent.CountDownLatch in Java 1.5
 //
 
-class ICE_UTIL_API CountDownLatch
+class ICE_API CountDownLatch
 {
 public:
-    
+
     CountDownLatch(int);
     ~CountDownLatch();
 
     void await() const;
     void countDown();
     int getCount() const;
-   
+
 private:
-   
+
 #ifdef _WIN32
     mutable LONG _count;
     HANDLE _event;

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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
@@ -16,53 +11,80 @@
 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);
+/**
+ * Invoked when a signal occurs. The callback must not raise exceptions.
+ * On Linux and macOS, the callback is NOT a signal handler and can call
+ * functions that are not async-signal safe.
+ * @param sig The signal number that occurred.
+ */
+#ifdef ICE_CPP11_MAPPING
+using CtrlCHandlerCallback = std::function<void(int sig)>;
+#else
+typedef void (*CtrlCHandlerCallback)(int sig);
+#endif
 
-class ICE_UTIL_API CtrlCHandler
+/**
+ * Provides a portable way to handle Ctrl-C and Ctrl-C like signals.
+ * On Linux and macOS, the CtrlCHandler handles SIGHUP, SIGINT and SIGTERM.
+ * On Windows, it is essentially a wrapper for SetConsoleCtrlHandler().
+ *
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API CtrlCHandler
 {
 public:
 
-    CtrlCHandler(CtrlCHandlerCallback = 0);
+     /**
+     * Registers a callback function that handles Ctrl-C like signals.
+     * On Linux and macOS, this constructor masks the SIGHUP, SIGINT and SIGTERM
+     * signals and then creates a thread that waits for these signals using sigwait.
+     * On Windows, this constructor calls SetConsoleCtrlCHandler to register a handler
+     * routine that calls the supplied callback function.
+     * Only a single CtrlCHandler object can exist in a process at a give time.
+     * @param cb The callback function to invoke when a signal is received.
+     */
+    explicit CtrlCHandler(CtrlCHandlerCallback cb = ICE_NULLPTR);
+
+     /**
+     * Unregisters the callback function.
+     * On Linux and macOS, this destructor joins and terminates the thread created
+     * by the constructor but does not "unmask" SIGHUP, SIGINT and SIGTERM. As a result,
+     * these signals are ignored after this destructor completes.
+     * On Windows, this destructor unregisters the SetConsoleCtrlHandler handler
+     * routine, and as a result a Ctrl-C or similar signal will terminate the application
+     * after this destructor completes.
+     */
     ~CtrlCHandler();
 
-    void setCallback(CtrlCHandlerCallback);
+    /**
+     * Replaces the signal callback.
+     * @param cb The new callback.
+     * @return The old callback, or nil if no callback is currently set.
+     */
+    CtrlCHandlerCallback setCallback(CtrlCHandlerCallback cb);
+
+    /**
+     * Obtains the signal callback.
+     * @return The callback.
+     */
     CtrlCHandlerCallback getCallback() const;
 };
 
-class ICE_UTIL_API CtrlCHandlerException : public Exception
-{ 
+/**
+ * Raised by the CtrlCHandler constructor if another CtrlCHandler already exists.
+ *
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API CtrlCHandlerException : public ExceptionHelper<CtrlCHandlerException>
+{
 public:
- 
+
     CtrlCHandlerException(const char*, int);
-    virtual std::string ice_name() const;
+    virtual std::string ice_id() const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual CtrlCHandlerException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 };
 
 }

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

@@ -1,18 +1,12 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.
+// This header file disables 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
@@ -25,15 +19,14 @@
 //
 #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)
+#    pragma warning(disable:4996) // C4996 '<function>' was declared deprecated
+#    pragma warning(disable: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
+#       pragma warning(disable:4355) // C4355 'this' : used in base member initializer list
 #    endif
 #endif
 
-
 //
 // GCC
 //
@@ -48,5 +41,4 @@
 #   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-
 #endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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
@@ -18,167 +13,381 @@
 namespace IceUtil
 {
 
-class ICE_UTIL_API Exception : public std::exception
+/**
+ * Abstract base class for all Ice exceptions. Use the Ice::Exception alias instead
+ * of IceUtil::Exception.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API Exception : public std::exception
 {
 public:
 
+    /**
+     * Constructs the exception. Equivalent to Exception(nullptr, 0).
+     */
     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;
+    /**
+     * Constructs the exception.
+     * @param file The file where this exception is constructed.
+     * @param line The line where this exception is constructed.
+     */
+    Exception(const char* file, int line);
+
+#ifndef ICE_CPP11_COMPILER
+    virtual ~Exception() throw() = 0;
+#endif
+
+    /**
+     * Returns the type ID of this exception. This corresponds to the Slice
+     * type ID for Slice-defined exceptions, and to a similar fully scoped name
+     * for other exceptions. For example "::IceUtil::SyscallException".
+     * @return The type ID of this exception
+     */
+    virtual std::string ice_id() const = 0;
+
+    /**
+     * Outputs a description of this exception to a stream.
+     * @param os The output stream.
+     */
+    virtual void ice_print(std::ostream& os) const;
+
+    /**
+     * Returns a description of this exception.
+     * @return The description.
+     */
+    virtual const char* what() const ICE_NOEXCEPT;
+#ifdef ICE_CPP11_MAPPING
+
+    /**
+     * Returns a shallow polymorphic copy of this exception.
+     * @return A unique_ptr to the new shallow copy.
+     */
+    std::unique_ptr<Exception> ice_clone() const;
+#else
+    /**
+     * Returns a shallow polymorphic copy of this exception.
+     * @return A pointer to the new shallow copy. The caller owns the returned object.
+     */
+    virtual Exception* ice_clone() const = 0;
+
+    ICE_DEPRECATED_API("ice_name() is deprecated, use ice_id() instead.")
+    std::string ice_name() const;
+#endif
 
+    /**
+     * Throws this exception.
+     */
+    virtual void ice_throw() const = 0;
+
+    /**
+     * Returns the name of the file where this exception was constructed.
+     * @return The file name.
+     */
     const char* ice_file() const;
+
+    /**
+     * Returns the line number where this exception was constructed.
+     * @return The line number.
+     */
     int ice_line() const;
+
+    /**
+     * Returns the stack trace at the point this exception was constructed
+     * @return The stack trace as a string.
+     */
     std::string ice_stackTrace() const;
-    
+
+protected:
+
+#ifdef ICE_CPP11_MAPPING
+    /// \cond INTERNAL
+    virtual Exception* ice_cloneImpl() const = 0;
+    /// \endcond
+#endif
+
 private:
-    
+
     const char* _file;
     int _line;
-    static const char* _name;
     const std::vector<void*> _stackFrames;
     mutable ::std::string _str; // Initialized lazily in what().
 };
 
-ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Exception&);
+ICE_API std::ostream& operator<<(std::ostream&, const Exception&);
+
+#ifdef ICE_CPP11_MAPPING
 
-class ICE_UTIL_API NullHandleException : public Exception
+/**
+ * Helper template for the implementation of Ice::Exception.
+ * It implements ice_clone and ice_throw.
+ * \headerfile Ice/Ice.h
+ */
+template<typename E, typename B = Exception>
+class ExceptionHelper : public B
 {
 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:
+    using B::B;
 
-    static const char* _name;
+    std::unique_ptr<E> ice_clone() const
+    {
+        return std::unique_ptr<E>(static_cast<E*>(ice_cloneImpl()));
+    }
+
+    virtual void ice_throw() const override
+    {
+        throw static_cast<const E&>(*this);
+    }
+
+protected:
+
+    /// \cond INTERNAL
+    virtual Exception* ice_cloneImpl() const override
+    {
+        return new E(static_cast<const E&>(*this));
+    }
+    /// \endcond
 };
 
-class ICE_UTIL_API IllegalArgumentException : public Exception
+#else // C++98 mapping
+
+/**
+ * Helper template for the implementation of Ice::Exception. It implements ice_throw.
+ * \headerfile Ice/Ice.h
+ */
+template<typename E>
+class ExceptionHelper : public Exception
 {
 public:
-    
+
+    ExceptionHelper()
+    {
+    }
+
+    ExceptionHelper(const char* file, int line) : Exception(file, line)
+    {
+    }
+
+    virtual void ice_throw() const
+    {
+        throw static_cast<const E&>(*this);
+    }
+};
+
+#endif
+
+/**
+ * This exception indicates an attempt to dereference a null IceUtil::Handle or
+ * IceInternal::Handle.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API NullHandleException : public ExceptionHelper<NullHandleException>
+{
+public:
+
+    NullHandleException(const char*, int);
+    virtual std::string ice_id() const;
+
+#ifndef ICE_CPP11_MAPPING
+    virtual NullHandleException* ice_clone() const;
+#endif
+};
+
+/**
+ * This exception indicates that a function was called with an illegal parameter
+ * value. It is used only by the Slice to C++98 mapping; std::invalid_argument is
+ * used by the Slice to C++11 mapping.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API IllegalArgumentException : public ExceptionHelper<IllegalArgumentException>
+{
+public:
+
     IllegalArgumentException(const char*, int);
     IllegalArgumentException(const char*, int, const std::string&);
+
+#ifndef ICE_CPP11_COMPILER
     virtual ~IllegalArgumentException() throw();
-    virtual std::string ice_name() const;
+#endif
+
+    virtual std::string ice_id() const;
     virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual IllegalArgumentException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 
+    /**
+     * Provides the reason this exception was thrown.
+     * @return The reason.
+     */
     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
+/**
+ * This exception indicates the failure of a string conversion.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API IllegalConversionException : public ExceptionHelper<IllegalConversionException>
 {
 public:
-    
+
     IllegalConversionException(const char*, int);
     IllegalConversionException(const char*, int, const std::string&);
+
+#ifndef ICE_CPP11_COMPILER
     virtual ~IllegalConversionException() throw();
-    virtual std::string ice_name() const;
+#endif
+
+    virtual std::string ice_id() const;
     virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual IllegalConversionException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 
+    /**
+     * Provides the reason this exception was thrown.
+     * @return The reason.
+     */
     std::string reason() const;
+
 private:
 
-    static const char* _name;   
     const std::string _reason;
 };
 
-
-class ICE_UTIL_API SyscallException : public Exception
+/**
+ * This exception indicates the failure of a system call.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API SyscallException : public ExceptionHelper<SyscallException>
 {
 public:
 
     SyscallException(const char*, int, int);
-    virtual std::string ice_name() const;
+
+#ifndef ICE_CPP11_COMPILER
+    virtual ~SyscallException() throw();
+#endif
+
+    virtual std::string ice_id() const;
     virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual SyscallException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 
+    /**
+     * Provides the error number returned by the system call.
+     * @return The error number.
+     */
     int error() const;
 
 private:
 
     const int _error;
-    static const char* _name;
 };
 
-class ICE_UTIL_API FileLockException : public Exception
+#ifdef ICE_CPP11_MAPPING
+
+template<typename E>
+using SyscallExceptionHelper = ExceptionHelper<E, SyscallException>;
+
+#else // C++98 mapping
+
+/**
+* Helper template for the implementation of SyscallException. It implements
+* ice_throw.
+* \headerfile Ice/Ice.h
+*/
+template<typename E>
+class SyscallExceptionHelper : public SyscallException
+{
+public:
+
+    SyscallExceptionHelper(const char* file, int line, int errorCode) :
+        SyscallException(file, line, errorCode)
+    {
+    }
+
+    virtual void ice_throw() const
+    {
+        throw static_cast<const E&>(*this);
+    }
+};
+
+#endif
+
+/**
+ * This exception indicates the failure to lock a file.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API FileLockException : public ExceptionHelper<FileLockException>
 {
 public:
 
     FileLockException(const char*, int, int, const std::string&);
+
+#ifndef ICE_CPP11_COMPILER
     virtual ~FileLockException() throw();
-    virtual std::string ice_name() const;
+#endif
+
+    virtual std::string ice_id() const;
     virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual FileLockException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 
+    /**
+     * Returns the path to the file.
+     * @return The file path.
+     */
     std::string path() const;
+
+    /**
+     * Returns the error number for the failed locking attempt.
+     * @return The error number.
+     */
     int error() const;
 
 private:
 
     const int _error;
-    static const char* _name;
     std::string _path;
 };
 
-class ICE_UTIL_API OptionalNotSetException : public Exception
+/**
+ * This exception indicates an IceUtil::Optional is not set.
+ * Used only by the Slice to C++98 mapping.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API OptionalNotSetException : public ExceptionHelper<OptionalNotSetException>
 {
 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:
+    OptionalNotSetException(const char*, int);
+    virtual std::string ice_id() const;
 
-    static const char* _name;
+#ifndef ICE_CPP11_MAPPING
+    virtual OptionalNotSetException* ice_clone() const;
+#endif
 };
 
-#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;
+namespace IceUtilInternal
+{
 
-private:
+enum StackTraceImpl { STNone, STDbghelp, STLibbacktrace, STLibbacktracePlus, STBacktrace };
 
-    static const char* _name;
-    std::string _reason;
-};
-#endif
+ICE_API StackTraceImpl stackTraceImpl();
 
 }