zeroc-ice 3.6.5 → 3.7.0

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

@@ -0,0 +1,97 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 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_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;
+extern ICE_API ConsoleErr consoleErr;
+
+#else
+
+extern ICE_API std::ostream& consoleOut;
+extern ICE_API std::ostream& consoleErr;
+
+#endif
+
+}
+
+#endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -19,19 +19,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,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -17,22 +17,22 @@ 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. 
+// 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: 
+//
+// 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 
+// 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 
+// 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 
+// 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
@@ -42,27 +42,33 @@ namespace IceUtil
 // TODO: Maybe the behavior on Windows should be the same? Now we
 // just restore the default behavior (TerminateProcess).
 
+#ifdef ICE_CPP11_MAPPING
+using CtrlCHandlerCallback = std::function<void(int)>;
+#else
 typedef void (*CtrlCHandlerCallback)(int);
+#endif
 
-class ICE_UTIL_API CtrlCHandler
+class ICE_API CtrlCHandler
 {
 public:
 
-    CtrlCHandler(CtrlCHandlerCallback = 0);
+    explicit CtrlCHandler(CtrlCHandlerCallback = ICE_NULLPTR);
     ~CtrlCHandler();
 
-    void setCallback(CtrlCHandlerCallback);
+    CtrlCHandlerCallback setCallback(CtrlCHandlerCallback);
     CtrlCHandlerCallback getCallback() const;
 };
 
-class ICE_UTIL_API CtrlCHandlerException : public Exception
-{ 
+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,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -33,7 +33,6 @@
 #    endif
 #endif
 
-
 //
 // GCC
 //
@@ -48,5 +47,4 @@
 #   pragma clang diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
-
 #endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -18,121 +18,227 @@
 namespace IceUtil
 {
 
-class ICE_UTIL_API Exception : public std::exception
+class ICE_API Exception : public std::exception
 {
 public:
 
     Exception();
     Exception(const char*, int);
-
-    virtual ~Exception() throw();
-    virtual std::string ice_name() const;
+#ifndef ICE_CPP11_COMPILER
+    virtual ~Exception() throw() = 0;
+#endif
+    virtual std::string ice_id() const = 0;
     virtual void ice_print(std::ostream&) const;
-    virtual const char* what() const throw();
-    virtual Exception* ice_clone() const;
-    virtual void ice_throw() const;
+    virtual const char* what() const ICE_NOEXCEPT;
+#ifdef ICE_CPP11_MAPPING
+    std::unique_ptr<Exception> ice_clone() const;
+#else
+    virtual Exception* ice_clone() const = 0;
+    ICE_DEPRECATED_API("ice_name() is deprecated, use ice_id() instead.")
+    std::string ice_name() const;
+#endif
+    virtual void ice_throw() const = 0;
 
     const char* ice_file() const;
     int ice_line() const;
     std::string ice_stackTrace() const;
-    
+
+protected:
+
+#ifdef ICE_CPP11_MAPPING
+    virtual Exception* ice_cloneImpl() const = 0;
+#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
+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;
+
+    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);
+    }
 
-    static const char* _name;
+protected:
+
+    virtual Exception* ice_cloneImpl() const override
+    {
+        return new E(static_cast<const E&>(*this));
+    }
 };
 
-class ICE_UTIL_API IllegalArgumentException : public Exception
+#else // C++98 mapping
+
+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
+
+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
+};
+
+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
 
     std::string reason() const;
 
 private:
 
-    static const char* _name;
     const std::string _reason;
 };
 
 //
-// IllegalConversionException is raised to report a string conversion error 
+// IllegalConversionException is raised to report a string conversion error
 //
-class ICE_UTIL_API IllegalConversionException : public Exception
+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
 
     std::string reason() const;
+
 private:
 
-    static const char* _name;   
     const std::string _reason;
 };
 
-
-class ICE_UTIL_API SyscallException : public Exception
+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
 
     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
+
+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
+
+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
 
     std::string path() const;
     int error() const;
@@ -140,45 +246,29 @@ public:
 private:
 
     const int _error;
-    static const char* _name;
     std::string _path;
 };
 
-class ICE_UTIL_API OptionalNotSetException : public Exception
+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();
 
 }