zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/IceUtil/ThreadException.cpp

@@ -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.
@@ -11,162 +11,125 @@
 
 using namespace std;
 
-IceUtil::ThreadSyscallException::ThreadSyscallException(const char* file, int line, int err ): 
-    SyscallException(file, line, err)
+IceUtil::ThreadSyscallException::ThreadSyscallException(const char* file, int line, int err ):
+    SyscallExceptionHelper<ThreadSyscallException>(file, line, err)
 {
 }
-    
-const char* IceUtil::ThreadSyscallException::_name = "IceUtil::ThreadSyscallException";
 
 string
-IceUtil::ThreadSyscallException::ice_name() const
+IceUtil::ThreadSyscallException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadSyscallException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadSyscallException*
 IceUtil::ThreadSyscallException::ice_clone() const
 {
     return new ThreadSyscallException(*this);
 }
-
-void
-IceUtil::ThreadSyscallException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 IceUtil::ThreadLockedException::ThreadLockedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadLockedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadLockedException::_name = "IceUtil::ThreadLockedException";
-
 string
-IceUtil::ThreadLockedException::ice_name() const
+IceUtil::ThreadLockedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadLockedException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadLockedException*
 IceUtil::ThreadLockedException::ice_clone() const
 {
     return new ThreadLockedException(*this);
 }
-
-void
-IceUtil::ThreadLockedException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 IceUtil::ThreadStartedException::ThreadStartedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadStartedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadStartedException::_name = "IceUtil::ThreadStartedException";
-
 string
-IceUtil::ThreadStartedException::ice_name() const
+IceUtil::ThreadStartedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadStartedException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadStartedException*
 IceUtil::ThreadStartedException::ice_clone() const
 {
     return new ThreadStartedException(*this);
 }
-
-void
-IceUtil::ThreadStartedException::ice_throw() const
-{
-    throw *this;
-}
+#endif
 
 IceUtil::ThreadNotStartedException::ThreadNotStartedException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<ThreadNotStartedException>(file, line)
 {
 }
 
-const char* IceUtil::ThreadNotStartedException::_name = "IceUtil::ThreadNotStartedException";
-
 string
-IceUtil::ThreadNotStartedException::ice_name() const
+IceUtil::ThreadNotStartedException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::ThreadNotStartedException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::ThreadNotStartedException*
 IceUtil::ThreadNotStartedException::ice_clone() const
 {
     return new ThreadNotStartedException(*this);
 }
-
-void
-IceUtil::ThreadNotStartedException::ice_throw() const
-{
-    throw *this;
-}
-
+#endif
 
 IceUtil::BadThreadControlException::BadThreadControlException(const char* file, int line) :
-    Exception(file, line)
+    ExceptionHelper<BadThreadControlException>(file, line)
 {
 }
 
-const char* IceUtil::BadThreadControlException::_name = "IceUtil::BadThreadControlException";
-
 string
-IceUtil::BadThreadControlException::ice_name() const
+IceUtil::BadThreadControlException::ice_id() const
 {
-    return _name;
+    return "::IceUtil::BadThreadControlException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::BadThreadControlException*
 IceUtil::BadThreadControlException::ice_clone() const
 {
     return new BadThreadControlException(*this);
 }
+#endif
 
-void
-IceUtil::BadThreadControlException::ice_throw() const
-{
-    throw *this;
-}
-
-IceUtil::InvalidTimeoutException::InvalidTimeoutException(const char* file, int line, 
-                                                          const IceUtil::Time& timeout) : 
-    Exception(file, line),
+IceUtil::InvalidTimeoutException::InvalidTimeoutException(const char* file, int line,
+                                                          const IceUtil::Time& timeout) :
+    ExceptionHelper<InvalidTimeoutException>(file, line),
     _timeout(timeout)
 {
 }
-    
-const char* IceUtil::InvalidTimeoutException::_name = "IceUtil::InvalidTimeoutException";
 
 string
-IceUtil::InvalidTimeoutException::ice_name() const
+IceUtil::InvalidTimeoutException::ice_id() const
 {
-    return _name;
-}
-
-void
-IceUtil::InvalidTimeoutException::ice_print(ostream& os) const
-{
-    Exception::ice_print(os);
-    os << ":\ninvalid timeout: " << _timeout << " seconds";
+    return "::IceUtil::InvalidTimeoutException";
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::InvalidTimeoutException*
 IceUtil::InvalidTimeoutException::ice_clone() const
 {
     return new InvalidTimeoutException(*this);
 }
+#endif
 
 void
-IceUtil::InvalidTimeoutException::ice_throw() const
+IceUtil::InvalidTimeoutException::ice_print(ostream& os) const
 {
-    throw *this;
+    Exception::ice_print(os);
+    os << ":\ninvalid timeout: " << _timeout << " seconds";
 }

data/ext/ice/cpp/src/IceUtil/Time.cpp

@@ -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.

data/ext/ice/cpp/src/IceUtil/UUID.cpp

@@ -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.
@@ -10,8 +10,8 @@
 #include <IceUtil/UUID.h>
 
 // On Windows, we use Windows's RPC UUID generator.
-// On other platforms, we use a high quality random number generator 
-// (/dev/random) to generate "version 4" UUIDs, as described in 
+// On other platforms, we use a high quality random number generator
+// (/dev/random) to generate "version 4" UUIDs, as described in
 // http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt
 
 #include <IceUtil/Random.h>
@@ -25,7 +25,7 @@
 
 using namespace std;
 
-#if defined(ICE_OS_WINRT) || !defined(_WIN32)
+#if defined(ICE_OS_UWP) || !defined(_WIN32)
 
 namespace
 {
@@ -43,7 +43,7 @@ namespace IceUtilInternal
 class PidInitializer
 {
 public:
-    
+
     PidInitializer()
     {
 #ifndef _WIN32
@@ -75,7 +75,7 @@ inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
     else
     {
         *hexBuffer++ = 'A' + (hb - 10);
-    } 
+    }
 }
 
 inline void bytesToHex(unsigned char* bytes, size_t len, char*& hexBuffer)
@@ -92,7 +92,7 @@ inline void bytesToHex(unsigned char* bytes, size_t len, char*& hexBuffer)
 string
 IceUtil::generateUUID()
 {
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
 
     UUID uuid;
     RPC_STATUS ret = UuidCreate(&uuid);
@@ -112,7 +112,7 @@ IceUtil::generateUUID()
 
     RpcStringFree(&str);
     return result;
-    
+
 #else
     struct UUID
     {
@@ -127,7 +127,7 @@ IceUtil::generateUUID()
 
     assert(sizeof(UUID) == 16);
 
-    // 
+    //
     // Get a random sequence of bytes. Instead of using 122 random
     // bits that could be duplicated (because of a bug with some Linux
     // kernels and potentially other Unix platforms -- see comment in
@@ -146,7 +146,7 @@ IceUtil::generateUUID()
     uuid.clockSeqHiAndReserved |= 0x80;
 
     //
-    // Replace the end of the node by myPid (15 bits) 
+    // Replace the end of the node by myPid (15 bits)
     //
     uuid.node[4] = (uuid.node[4] & 0x80) | myPid[0];
     uuid.node[5] = myPid[1];

data/ext/ice/cpp/src/IceUtil/Unicode.cpp

@@ -1,13 +1,23 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
+#include <IceUtil/Config.h>
+
+#ifndef ICE_HAS_CODECVT_UTF8
+//
+// It's better to exclude the file from the build, but it's not always
+// easy to do.
+//
+
 #include <IceUtil/Unicode.h>
+#include <IceUtil/Exception.h>
+
 #include <IceUtil/ConvertUTF.h>
 
 using namespace std;
@@ -20,39 +30,29 @@ namespace
 // Helper class, base never defined
 // Usage: WstringHelper<sizeof(wchar_t)>::toUTF8 and fromUTF8.
 //
-template<size_t wcharSize> 
-struct WstringHelper
-{
-    static ConversionResult toUTF8(
-        const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
-        Byte*& targetStart, Byte* targetEnd, ConversionFlags flags);
-
-    static ConversionResult fromUTF8(
-        const Byte*& sourceStart, const Byte* sourceEnd, 
-        wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags);
-};
+template<size_t wcharSize> struct WstringHelper;
 
 template<>
 struct WstringHelper<2>
 {
     static ConversionResult toUTF8(
-        const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
-        Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+        const wchar_t*& sourceStart, const wchar_t* sourceEnd,
+        Byte*& targetStart, Byte* targetEnd)
     {
         return ConvertUTF16toUTF8(
             reinterpret_cast<const UTF16**>(&sourceStart),
             reinterpret_cast<const UTF16*>(sourceEnd),
-            &targetStart, targetEnd, flags);
+            &targetStart, targetEnd, lenientConversion);
     }
-    
+
     static ConversionResult fromUTF8(
-        const Byte*& sourceStart, const Byte* sourceEnd, 
-        wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags)
+        const Byte*& sourceStart, const Byte* sourceEnd,
+        wchar_t*& targetStart, wchar_t* targetEnd)
     {
         return ConvertUTF8toUTF16(
             &sourceStart, sourceEnd,
             reinterpret_cast<UTF16**>(&targetStart),
-            reinterpret_cast<UTF16*>(targetEnd), flags);
+            reinterpret_cast<UTF16*>(targetEnd), lenientConversion);
     }
 };
 
@@ -60,128 +60,129 @@ template<>
 struct WstringHelper<4>
 {
     static ConversionResult toUTF8(
-        const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
-        Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+        const wchar_t*& sourceStart, const wchar_t* sourceEnd,
+        Byte*& targetStart, Byte* targetEnd)
     {
         return ConvertUTF32toUTF8(
             reinterpret_cast<const UTF32**>(&sourceStart),
             reinterpret_cast<const UTF32*>(sourceEnd),
-            &targetStart, targetEnd, flags);
+            &targetStart, targetEnd, lenientConversion);
     }
-    
+
     static ConversionResult fromUTF8(
-        const Byte*& sourceStart, const Byte* sourceEnd, 
-        wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags)
+        const Byte*& sourceStart, const Byte* sourceEnd,
+        wchar_t*& targetStart, wchar_t* targetEnd)
     {
         return ConvertUTF8toUTF32(
             &sourceStart, sourceEnd,
             reinterpret_cast<UTF32**>(&targetStart),
-            reinterpret_cast<UTF32*>(targetEnd), flags);
+            reinterpret_cast<UTF32*>(targetEnd), lenientConversion);
     }
 };
+
+void checkResult(ConversionResult result)
+{
+    switch (result)
+    {
+        case conversionOK:
+            break;
+        case sourceExhausted:
+            throw IceUtil::IllegalConversionException(__FILE__, __LINE__, "source exhausted");
+        case sourceIllegal:
+            throw IceUtil::IllegalConversionException(__FILE__, __LINE__, "source illegal");
+        case targetExhausted:
+            throw IceUtil::IllegalConversionException(__FILE__, __LINE__, "source illegal");
+        default:
+        {
+            assert(0);
+            throw IceUtil::IllegalConversionException(__FILE__, __LINE__);
+        }
+    }
+}
 }
 
 //
 // convertXXX functions
 //
 
-ConversionResult 
-IceUtilInternal::convertUTFWstringToUTF8(
-    const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
-    Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+bool
+IceUtilInternal::convertUTFWstringToUTF8(const wchar_t*& sourceStart, const wchar_t* sourceEnd,
+                                         Byte*& targetStart, Byte* targetEnd)
 {
-    return WstringHelper<sizeof(wchar_t)>::toUTF8(
-        sourceStart, sourceEnd, targetStart, targetEnd, flags);
-}
+    ConversionResult result = WstringHelper<sizeof(wchar_t)>::toUTF8(
+        sourceStart, sourceEnd, targetStart, targetEnd);
 
-ConversionResult
-IceUtilInternal::convertUTF8ToUTFWstring(
-    const Byte*& sourceStart, const Byte* sourceEnd, 
-    wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags)
-{
-    return WstringHelper<sizeof(wchar_t)>::fromUTF8(
-        sourceStart, sourceEnd, targetStart, targetEnd, flags);
+    if(result == targetExhausted)
+    {
+        return false;
+    }
+    else
+    {
+        checkResult(result);
+        return true;
+    }
 }
 
-ConversionResult 
-IceUtilInternal::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd, 
-                                 std::wstring& target, ConversionFlags flags)
+void
+IceUtilInternal::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd, std::wstring& target)
 {
-    //
-    // Could be reimplemented without this temporary wchar_t buffer
-    //
-    size_t size = static_cast<size_t>(sourceEnd - sourceStart);
-    wchar_t* outBuf = new wchar_t[size];
-    wchar_t* targetStart = outBuf; 
-    wchar_t* targetEnd = targetStart + size;
-
-    ConversionResult result =  
-        convertUTF8ToUTFWstring(sourceStart, sourceEnd, targetStart,
-                                targetEnd, flags);
-
-    if(result == conversionOK)
-    {
-        std::wstring s(outBuf, static_cast<size_t>(targetStart - outBuf));
-        s.swap(target);
-    }
-    delete[] outBuf;
-    return result;
+    size_t sourceSize = static_cast<size_t>(sourceEnd - sourceStart);
+
+    target.resize(sourceSize);
+    wchar_t* targetStart = const_cast<wchar_t*>(target.data());
+    wchar_t* targetEnd = targetStart + sourceSize;
+
+    ConversionResult result = WstringHelper<sizeof(wchar_t)>::fromUTF8(sourceStart, sourceEnd,
+                                                                       targetStart, targetEnd);
+
+    checkResult(result);
+    target.resize(targetStart - target.data());
 }
 
-ConversionResult
-IceUtilInternal::convertUTF8ToUTF16(const vector<unsigned char>& source, vector<unsigned short>& target, ConversionFlags flags)
+void
+IceUtilInternal::convertUTF8ToUTF16(const vector<unsigned char>& source, vector<unsigned short>& target)
 {
     target.resize(source.size());
     const unsigned char* sourceStart = &source[0];
     const unsigned char* sourceEnd = &source[0] + source.size();
-    
-    unsigned short* targetStart = &target[0]; 
+
+    unsigned short* targetStart = &target[0];
     unsigned short* targetEnd = &target[0] + target.size();
-    ConversionResult result = ConvertUTF8toUTF16(&sourceStart, sourceEnd, &targetStart, targetEnd, flags);
-    
-    if(result == conversionOK)
-    {
-        target.resize(targetStart - &target[0]);
-    }
-    return result;
+    ConversionResult result = ConvertUTF8toUTF16(&sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);
+
+    checkResult(result);
+    target.resize(targetStart - &target[0]);
 }
 
-ConversionResult
-IceUtilInternal::convertUTF8ToUTF32(const vector<unsigned char>& source, vector<unsigned int>& target, ConversionFlags flags)
+void
+IceUtilInternal::convertUTF8ToUTF32(const vector<unsigned char>& source, vector<unsigned int>& target)
 {
     target.resize(source.size());
     const unsigned char* sourceStart = &source[0];
     const unsigned char* sourceEnd = &source[0] + source.size();
-    
-    unsigned int* targetStart = &target[0]; 
+
+    unsigned int* targetStart = &target[0];
     unsigned int* targetEnd = &target[0] + target.size();
-    ConversionResult result = ConvertUTF8toUTF32(&sourceStart, sourceEnd, &targetStart, targetEnd, flags);
-    
-    if(result == conversionOK)
-    {
-        target.resize(targetStart - &target[0]);
-    }
-    return result;
+    ConversionResult result = ConvertUTF8toUTF32(&sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);
+
+    checkResult(result);
+    target.resize(targetStart - &target[0]);
 }
 
-ConversionResult
-IceUtilInternal::convertUTF32ToUTF8(const vector<unsigned int>& source, vector<unsigned char>& target, ConversionFlags flags)
+void
+IceUtilInternal::convertUTF32ToUTF8(const vector<unsigned int>& source, vector<unsigned char>& target)
 {
     target.resize(source.size() * 4);
 
     const unsigned int* sourceStart = &source[0];
     const unsigned int* sourceEnd = &source[0] + source.size();
-    
-    unsigned char* targetStart = &target[0]; 
-    unsigned char* targetEnd = &target[0] + target.size();
-    ConversionResult result = ConvertUTF32toUTF8(&sourceStart, sourceEnd, &targetStart, targetEnd, flags);
-    
-    if(result == conversionOK)
-    {
-        target.resize(targetStart - &target[0]);
-    }
-    return result;
-}
 
+    unsigned char* targetStart = &target[0];
+    unsigned char* targetEnd = &target[0] + target.size();
+    ConversionResult result = ConvertUTF32toUTF8(&sourceStart, sourceEnd, &targetStart, targetEnd, lenientConversion);
 
+    checkResult(result);
+    target.resize(targetStart - &target[0]);
+}
 
+#endif