zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,14 +1,14 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#ifndef ICE_STRING_UTIL_H
-#define ICE_STRING_UTIL_H
+#ifndef ICE_UTIL_STRING_UTIL_H
+#define ICE_UTIL_STRING_UTIL_H
 
 #include <IceUtil/Config.h>
 #include <vector>
@@ -17,32 +17,43 @@ namespace IceUtilInternal
 {
 
 //
-// Add escape sequences (like "\n", or "\0xxx") to make a string
-// readable in ASCII.
+// Must be kept in sync with Ice::ToStringMode
 //
-ICE_UTIL_API std::string escapeString(const std::string&, const std::string&);
+#ifdef ICE_CPP11_MAPPING
+enum class ToStringMode : unsigned char
+#else
+enum ToStringMode
+#endif
+{ Unicode, ASCII, Compat };
+
+//
+// Add escape sequences (like "\n", or "\123") to the input string
+// (first parameter).
+// The second parameter adds characters to escape, and can be empty.
+//
+ICE_API std::string escapeString(const std::string&, const std::string&, ToStringMode);
 
 //
 // Remove escape sequences added by escapeString. Throws IllegalArgumentException
 // for an invalid input string.
 //
-ICE_UTIL_API std::string unescapeString(const std::string&, std::string::size_type, std::string::size_type);
+ICE_API std::string unescapeString(const std::string&, std::string::size_type, std::string::size_type, const std::string&);
 
 //
 // Split a string using the given delimiters. Considers single and double quotes;
 // returns false for unbalanced quote, true otherwise.
 //
-ICE_UTIL_API bool splitString(const std::string&, const std::string&, std::vector<std::string>&);
+ICE_API bool splitString(const std::string&, const std::string&, std::vector<std::string>&);
 
 //
-// Join a list of strings using the given delimiter. 
+// Join a list of strings using the given delimiter.
 //
-ICE_UTIL_API std::string joinString(const std::vector<std::string>&, const std::string&);
+ICE_API std::string joinString(const std::vector<std::string>&, const std::string&);
 
 //
 // Trim white space
 //
-ICE_UTIL_API std::string trim(const std::string&);
+ICE_API std::string trim(const std::string&);
 
 //
 // If a single or double quotation mark is found at the start
@@ -51,7 +62,7 @@ ICE_UTIL_API std::string trim(const std::string&);
 // 0 is returned. If no matching closing quote is found, then
 // std::string::npos is returned.
 //
-ICE_UTIL_API std::string::size_type checkQuote(const std::string&, std::string::size_type = 0);
+ICE_API std::string::size_type checkQuote(const std::string&, std::string::size_type = 0);
 
 //
 // Match `s' against the pattern `pat'. A * in the pattern acts
@@ -59,16 +70,16 @@ ICE_UTIL_API std::string::size_type checkQuote(const std::string&, std::string::
 // other than a period (`.'). We match by hand here because
 // it's portable across platforms (whereas regex() isn't).
 //
-ICE_UTIL_API bool match(const std::string&, const std::string&, bool = false);
+ICE_API bool match(const std::string&, const std::string&, bool = false);
 
 //
 // Get the error message for the last error code or given error code.
 //
-ICE_UTIL_API std::string lastErrorToString();
+ICE_API std::string lastErrorToString();
 #ifdef _WIN32
-ICE_UTIL_API std::string errorToString(int, LPCVOID = NULL);
+ICE_API std::string errorToString(int, LPCVOID = ICE_NULLPTR);
 #else
-ICE_UTIL_API std::string errorToString(int);
+ICE_API std::string errorToString(int);
 #endif
 
 //
@@ -76,15 +87,15 @@ ICE_UTIL_API std::string errorToString(int);
 // UTF8 string/characters but ignore non ASCII characters. Unlike, the
 // C methods, these methods are not local dependent.
 //
-ICE_UTIL_API std::string toLower(const std::string&);
-ICE_UTIL_API std::string toUpper(const std::string&);
-ICE_UTIL_API bool isAlpha(char);
-ICE_UTIL_API bool isDigit(char);
+ICE_API std::string toLower(const std::string&);
+ICE_API std::string toUpper(const std::string&);
+ICE_API bool isAlpha(char);
+ICE_API bool isDigit(char);
 
 //
 // Remove all whitespace from a string
 //
-ICE_UTIL_API std::string removeWhitespace(const std::string&);
+ICE_API std::string removeWhitespace(const std::string&);
 
 }
 

data/ext/ice/cpp/include/IceUtil/Thread.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.
@@ -15,7 +15,7 @@
 #include <IceUtil/Handle.h>
 #include <IceUtil/Mutex.h>
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 #   include <memory>
 #   include <thread>
 #endif
@@ -25,7 +25,7 @@ namespace IceUtil
 
 class Time;
 
-class ICE_UTIL_API ThreadControl
+class ICE_API ThreadControl
 {
 public:
 
@@ -35,7 +35,7 @@ public:
     //
     ThreadControl();
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     ThreadControl(const std::shared_ptr<std::thread>&);
 #elif defined(_WIN32)
     ThreadControl(HANDLE, DWORD);
@@ -80,13 +80,13 @@ public:
     // id() returns the Thread ID on Windows and the underlying pthread_t
     // on POSIX platforms.
     //
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     typedef std::thread::id ID;
 #elif defined(_WIN32)
     typedef DWORD ID;
 #else
     typedef pthread_t ID;
-#endif 
+#endif
     ID id() const;
 
     static void sleep(const Time&);
@@ -94,7 +94,7 @@ public:
 
 private:
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     std::shared_ptr<std::thread> _thread;
     std::thread::id _id;
 #elif defined(_WIN32)
@@ -112,7 +112,7 @@ private:
 #endif
 };
 
-class ICE_UTIL_API Thread : virtual public IceUtil::Shared
+class ICE_API Thread : public virtual IceUtil::Shared
 {
 public:
 
@@ -128,7 +128,6 @@ public:
     ThreadControl getThreadControl() const;
 
     bool operator==(const Thread&) const;
-    bool operator!=(const Thread&) const;
     bool operator<(const Thread&) const;
 
     //
@@ -153,7 +152,7 @@ protected:
     bool _started;
     bool _running;
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     std::shared_ptr<std::thread> _thread;
 #elif defined(_WIN32)
     HANDLE _handle;
@@ -174,8 +173,7 @@ private:
 };
 
 typedef Handle<Thread> ThreadPtr;
-    
+
 }
 
 #endif
-

data/ext/ice/cpp/include/IceUtil/ThreadException.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.
@@ -16,93 +16,84 @@
 namespace IceUtil
 {
 
-class ICE_UTIL_API ThreadSyscallException : public SyscallException
+class ICE_API ThreadSyscallException : public SyscallExceptionHelper<ThreadSyscallException>
 {
 public:
 
     ThreadSyscallException(const char*, int, int);
-    virtual std::string ice_name() const;
-    virtual ThreadSyscallException* ice_clone() const;
-    virtual void ice_throw() const;
-
-private:
+    virtual std::string ice_id() const;
 
-    static const char* _name;
+#ifndef ICE_CPP11_MAPPING
+    virtual ThreadSyscallException* ice_clone() const;
+#endif
 };
 
-class ICE_UTIL_API ThreadLockedException : public Exception
+class ICE_API ThreadLockedException : public ExceptionHelper<ThreadLockedException>
 {
 public:
 
     ThreadLockedException(const char*, int);
-    virtual std::string ice_name() const;
-    virtual ThreadLockedException* ice_clone() const;
-    virtual void ice_throw() const;
-
-private:
+    virtual std::string ice_id() const;
 
-    static const char* _name;
+#ifndef ICE_CPP11_MAPPING
+    virtual ThreadLockedException* ice_clone() const;
+#endif
 };
 
-class ICE_UTIL_API ThreadStartedException : public Exception
+class ICE_API ThreadStartedException : public ExceptionHelper<ThreadStartedException>
 {
 public:
 
     ThreadStartedException(const char*, int);
-    virtual std::string ice_name() const;
-    virtual ThreadStartedException* ice_clone() const;
-    virtual void ice_throw() const;
+    virtual std::string ice_id() const;
 
-private:
+#ifndef ICE_CPP11_MAPPING
+    virtual ThreadStartedException* ice_clone() const;
+#endif
 
-    static const char* _name;
 };
 
-class ICE_UTIL_API ThreadNotStartedException : public Exception
+class ICE_API ThreadNotStartedException : public ExceptionHelper<ThreadNotStartedException>
 {
 public:
 
     ThreadNotStartedException(const char*, int);
-    virtual std::string ice_name() const;
-    virtual ThreadNotStartedException* ice_clone() const;
-    virtual void ice_throw() const;
+    virtual std::string ice_id() const;
 
-private:
-
-    static const char* _name;
+#ifndef ICE_CPP11_MAPPING
+    virtual ThreadNotStartedException* ice_clone() const;
+#endif
 };
 
-class ICE_UTIL_API BadThreadControlException : public Exception
+class ICE_API BadThreadControlException : public ExceptionHelper<BadThreadControlException>
 {
 public:
 
     BadThreadControlException(const char*, int);
-    virtual std::string ice_name() const;
-    virtual BadThreadControlException* ice_clone() const;
-    virtual void ice_throw() const;
-
-private:
+    virtual std::string ice_id() const;
 
-    static const char* _name;
+#ifndef ICE_CPP11_MAPPING
+    virtual BadThreadControlException* ice_clone() const;
+#endif
 };
 
-class ICE_UTIL_API InvalidTimeoutException : public Exception
+class ICE_API InvalidTimeoutException : public ExceptionHelper<InvalidTimeoutException>
 {
 public:
 
     InvalidTimeoutException(const char*, int, const Time&);
-    virtual std::string ice_name() const;
+    virtual std::string ice_id() const;
     virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
     virtual InvalidTimeoutException* ice_clone() const;
-    virtual void ice_throw() const;
+#endif
 
 private:
-    
+
     Time _timeout;
-    static const char* _name;
 };
-    
+
 }
 
 #endif
-

data/ext/ice/cpp/include/IceUtil/Time.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,7 +19,7 @@
 namespace IceUtil
 {
 
-class ICE_UTIL_API Time
+class ICE_API Time
 {
 public:
 
@@ -203,7 +203,7 @@ private:
     Int64 _usec;
 };
 
-ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Time&);
+ICE_API std::ostream& operator<<(std::ostream&, const Time&);
 
 } // End namespace IceUtil
 

data/ext/ice/cpp/include/IceUtil/Timer.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.
@@ -28,22 +28,25 @@ typedef IceUtil::Handle<Timer> TimerPtr;
 // Extend the TimerTask class and override the runTimerTask() method to execute
 // code at a specific time or repeatedly.
 //
-class ICE_UTIL_API TimerTask : virtual public IceUtil::Shared
+class ICE_API TimerTask
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
 {
 public:
 
-    virtual ~TimerTask() { }
+    virtual ~TimerTask();
 
     virtual void runTimerTask() = 0;
 };
-typedef IceUtil::Handle<TimerTask> TimerTaskPtr;
+ICE_DEFINE_PTR(TimerTaskPtr, TimerTask);
 
 //
 // The timer class is used to schedule tasks for one-time execution or
-// repeated execution. Tasks are executed by the dedicated timer thread 
+// repeated execution. Tasks are executed by the dedicated timer thread
 // sequentially.
 //
-class ICE_UTIL_API Timer : virtual public IceUtil::Shared, private IceUtil::Thread
+class ICE_API Timer : public virtual IceUtil::Shared, private IceUtil::Thread
 {
 public:
 
@@ -52,14 +55,13 @@ public:
     //
     Timer();
 
-
     //
     // Construct a timer and starts its execution thread with the priority.
     //
     Timer(int priority);
 
     //
-    // Destroy the timer and detach its execution thread if the calling thread 
+    // Destroy the timer and detach its execution thread if the calling thread
     // is the timer thread, join the timer execution thread otherwise.
     //
     void destroy();
@@ -101,11 +103,11 @@ protected:
     IceUtil::Monitor<IceUtil::Mutex> _monitor;
     bool _destroyed;
     std::set<Token> _tokens;
-    
+
     class TimerTaskCompare : public std::binary_function<TimerTaskPtr, TimerTaskPtr, bool>
     {
     public:
-        
+
         bool operator()(const TimerTaskPtr& lhs, const TimerTaskPtr& rhs) const
         {
             return lhs.get() < rhs.get();
@@ -116,7 +118,7 @@ protected:
 };
 typedef IceUtil::Handle<Timer> TimerPtr;
 
-inline 
+inline
 Timer::Token::Token(const IceUtil::Time& st, const IceUtil::Time& d, const TimerTaskPtr& t) :
     scheduledTime(st), delay(d), task(t)
 {
@@ -133,11 +135,10 @@ Timer::Token::operator<(const Timer::Token& r) const
     {
         return false;
     }
-    
+
     return task.get() < r.task.get();
 }
 
 }
 
 #endif
-