zeroc-ice 3.6b1

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

@@ -0,0 +1,251 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#include <IceUtil/Timer.h>
+#include <IceUtil/Exception.h>
+
+using namespace std;
+using namespace IceUtil;
+
+Timer::Timer() :
+    Thread("IceUtil timer thread"),
+    _destroyed(false)
+{
+    __setNoDelete(true);
+    start();
+    __setNoDelete(false);
+}
+
+Timer::Timer(int priority) :
+    Thread("IceUtil timer thread"),
+    _destroyed(false)
+{
+    __setNoDelete(true);
+    start(0, priority);
+    __setNoDelete(false);
+}
+
+void
+Timer::destroy()
+{
+    {
+        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+        if(_destroyed)
+        {
+            return;
+        }
+        _destroyed = true;
+        _monitor.notify();
+        _tasks.clear();
+        _tokens.clear();
+    }
+
+    if(getThreadControl() == ThreadControl())
+    {
+        getThreadControl().detach();
+    }
+    else
+    {
+        getThreadControl().join();
+    }
+}
+
+void
+Timer::schedule(const TimerTaskPtr& task, const IceUtil::Time& delay)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+    if(_destroyed)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "timer destroyed");
+    }
+
+    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
+    IceUtil::Time time = now + delay;
+    if(delay > IceUtil::Time() && time < now)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
+    }
+
+    bool inserted = _tasks.insert(make_pair(task, time)).second;
+    if(!inserted)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+    }
+    _tokens.insert(Token(time, IceUtil::Time(), task));
+
+    if(_wakeUpTime == IceUtil::Time() || time < _wakeUpTime)
+    {
+        _monitor.notify();
+    }
+}
+
+void
+Timer::scheduleRepeated(const TimerTaskPtr& task, const IceUtil::Time& delay)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+    if(_destroyed)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "timer destroyed");
+    }
+
+    IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
+    const Token token(now + delay, delay, task);
+    if(delay > IceUtil::Time() && token.scheduledTime < now) 
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "invalid delay");
+    }
+
+    bool inserted = _tasks.insert(make_pair(task, token.scheduledTime)).second;
+    if(!inserted)
+    {
+        throw IllegalArgumentException(__FILE__, __LINE__, "task is already schedulded");
+    }
+    _tokens.insert(token); 
+   
+    if(_wakeUpTime == IceUtil::Time() || token.scheduledTime < _wakeUpTime)
+    {
+        _monitor.notify();
+    }
+}
+
+bool
+Timer::cancel(const TimerTaskPtr& task)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+    if(_destroyed)
+    {
+        return false;
+    }
+
+    map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare>::iterator p = _tasks.find(task);
+    if(p == _tasks.end())
+    {
+        return false;
+    }
+
+    _tokens.erase(Token(p->second, IceUtil::Time(), p->first));
+    _tasks.erase(p);
+
+    return true;
+}
+
+void
+Timer::run()
+{
+    Token token(IceUtil::Time(), IceUtil::Time(), 0);
+    while(true)
+    {
+        {
+            IceUtil::Monitor<IceUtil::Mutex>::Lock sync(_monitor);
+
+            if(!_destroyed)
+            {
+                //
+                // If the task we just ran is a repeated task, schedule it
+                // again for executation if it wasn't canceled.
+                //
+                if(token.delay != IceUtil::Time())
+                {
+                    map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare>::iterator p = _tasks.find(token.task);
+                    if(p != _tasks.end())
+                    {
+                        token.scheduledTime = IceUtil::Time::now(IceUtil::Time::Monotonic) + token.delay;
+                        p->second = token.scheduledTime;
+                        _tokens.insert(token);
+                    }
+                }
+                token = Token(IceUtil::Time(), IceUtil::Time(), 0);
+
+                if(_tokens.empty())
+                {
+                    _wakeUpTime = IceUtil::Time();
+                    _monitor.wait();
+                }
+            }
+            
+            if(_destroyed)
+            {
+                break;
+            }
+            
+            while(!_tokens.empty() && !_destroyed)
+            {
+                const IceUtil::Time now = IceUtil::Time::now(IceUtil::Time::Monotonic);
+                const Token& first = *(_tokens.begin());
+                if(first.scheduledTime <= now)
+                {
+                    token = first;
+                    _tokens.erase(_tokens.begin());
+                    if(token.delay == IceUtil::Time())
+                    {
+                        _tasks.erase(token.task);
+                    }
+                    break;
+                }
+                
+                _wakeUpTime = first.scheduledTime;
+                try 
+                {
+                    _monitor.timedWait(first.scheduledTime - now);
+                } 
+                catch(const IceUtil::InvalidTimeoutException&)
+                {
+                    IceUtil::Time timeout = (first.scheduledTime - now) / 2;
+                    while(timeout > IceUtil::Time())
+                    {
+                        try 
+                        {
+                            _monitor.timedWait(timeout);
+                            break;
+                        } 
+                        catch(const IceUtil::InvalidTimeoutException&)
+                        {
+                            timeout = timeout / 2;
+                        }
+                    }
+                }
+            }
+
+            if(_destroyed)
+            {
+                break;
+            }
+        }     
+
+        if(token.task)
+        {
+            try
+            {
+                runTimerTask(token.task);
+            }
+            catch(const IceUtil::Exception& e)
+            {
+                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what();
+#ifdef __GNUC__
+                cerr << "\n" << e.ice_stackTrace();
+#endif
+                cerr << endl;
+            } 
+            catch(const std::exception& e)
+            {
+                cerr << "IceUtil::Timer::run(): uncaught exception:\n" << e.what() << endl;
+            } 
+            catch(...)
+            {
+                cerr << "IceUtil::Timer::run(): uncaught exception" << endl;
+            }
+        }
+    }
+}
+
+void
+Timer::runTimerTask(const TimerTaskPtr& task)
+{
+    task->runTimerTask();
+}

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

@@ -0,0 +1,174 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#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 
+// http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt
+
+#include <IceUtil/Random.h>
+
+#ifdef _WIN32
+#   include <rpc.h>
+#else
+#   include <sys/types.h>
+#   include <unistd.h>
+#endif
+
+using namespace std;
+
+#if defined(ICE_OS_WINRT) || !defined(_WIN32)
+
+namespace
+{
+
+char myPid[2];
+
+}
+
+namespace IceUtilInternal
+{
+
+//
+// Initialize the pid.
+//
+class PidInitializer
+{
+public:
+    
+    PidInitializer()
+    {
+#ifndef _WIN32
+        pid_t p = getpid();
+#else
+        int p = GetCurrentProcessId();
+#endif
+        myPid[0] = (p >> 8) & 0x7F;
+        myPid[1] = p & 0xFF;
+    }
+};
+
+PidInitializer pidInitializer;
+
+};
+#endif
+
+namespace
+{
+
+// Helper char to hex functions
+//
+inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
+{
+    if(hb < 10)
+    {
+        *hexBuffer++ = '0' + hb;
+    }
+    else
+    {
+        *hexBuffer++ = 'A' + (hb - 10);
+    } 
+}
+
+inline void bytesToHex(unsigned char* bytes, size_t len, char*& hexBuffer)
+{
+    for(size_t i = 0; i < len; i++)
+    {
+        halfByteToHex((bytes[i] & 0xF0) >> 4, hexBuffer);
+        halfByteToHex((bytes[i] & 0x0F), hexBuffer);
+    }
+}
+
+}
+
+string
+IceUtil::generateUUID()
+{
+#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+
+    UUID uuid;
+    RPC_STATUS ret = UuidCreate(&uuid);
+    if(ret != RPC_S_OK && ret != RPC_S_UUID_LOCAL_ONLY && ret != RPC_S_UUID_NO_ADDRESS)
+    {
+        throw new SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+
+    unsigned char* str;
+
+    ret = UuidToString(&uuid, &str);
+    if(ret != RPC_S_OK)
+    {
+        throw new SyscallException(__FILE__, __LINE__, GetLastError());
+    }
+    string result = reinterpret_cast<char*>(str);
+
+    RpcStringFree(&str);
+    return result;
+    
+#else
+    struct UUID
+    {
+        unsigned char timeLow[4];
+        unsigned char timeMid[2];
+        unsigned char timeHighAndVersion[2];
+        unsigned char clockSeqHiAndReserved;
+        unsigned char clockSeqLow;
+        unsigned char node[6];
+    };
+    UUID uuid;
+
+    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
+    // Random.cpp), we replace the last 15 bits of all "random"
+    // Randoms by the last 15 bits of the process id.
+    //
+    char* buffer = reinterpret_cast<char*>(&uuid);
+    IceUtilInternal::generateRandom(buffer, sizeof(UUID));
+
+    //
+    // Adjust the bits that say "version 4" UUID
+    //
+    uuid.timeHighAndVersion[0] &= 0x0F;
+    uuid.timeHighAndVersion[0] |= (4 << 4);
+    uuid.clockSeqHiAndReserved &= 0x3F;
+    uuid.clockSeqHiAndReserved |= 0x80;
+
+    //
+    // Replace the end of the node by myPid (15 bits) 
+    //
+    uuid.node[4] = (uuid.node[4] & 0x80) | myPid[0];
+    uuid.node[5] = myPid[1];
+
+    //
+    // Convert to a UUID string
+    //
+    char uuidString[16 * 2 + 4 + 1]; // 16 bytes, 4 '-' and a final '\0'
+    char* uuidIndex = uuidString;
+    bytesToHex(uuid.timeLow, sizeof(uuid.timeLow), uuidIndex);
+    *uuidIndex++ = '-';
+    bytesToHex(uuid.timeMid, sizeof(uuid.timeMid), uuidIndex);
+    *uuidIndex++ = '-';
+    bytesToHex(uuid.timeHighAndVersion, sizeof(uuid.timeHighAndVersion), uuidIndex);
+    *uuidIndex++ = '-';
+    bytesToHex(&uuid.clockSeqHiAndReserved, sizeof(uuid.clockSeqHiAndReserved), uuidIndex);
+    bytesToHex(&uuid.clockSeqLow, sizeof(uuid.clockSeqLow), uuidIndex);
+    *uuidIndex++ = '-';
+    bytesToHex(uuid.node, sizeof(uuid.node), uuidIndex);
+    *uuidIndex = '\0';
+
+    return uuidString;
+
+#endif
+}

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

@@ -0,0 +1,131 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#include <IceUtil/Unicode.h>
+#include <IceUtil/ConvertUTF.h>
+
+using namespace std;
+using namespace IceUtil;
+using namespace IceUtilInternal;
+
+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<>
+struct WstringHelper<2>
+{
+    static ConversionResult toUTF8(
+        const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
+        Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+    {
+        return ConvertUTF16toUTF8(
+            reinterpret_cast<const UTF16**>(&sourceStart),
+            reinterpret_cast<const UTF16*>(sourceEnd),
+            &targetStart, targetEnd, flags);
+    }
+    
+    static ConversionResult fromUTF8(
+        const Byte*& sourceStart, const Byte* sourceEnd, 
+        wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags)
+    {
+        return ConvertUTF8toUTF16(
+            &sourceStart, sourceEnd,
+            reinterpret_cast<UTF16**>(&targetStart),
+            reinterpret_cast<UTF16*>(targetEnd), flags);
+    }
+};
+
+template<>
+struct WstringHelper<4>
+{
+    static ConversionResult toUTF8(
+        const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
+        Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+    {
+        return ConvertUTF32toUTF8(
+            reinterpret_cast<const UTF32**>(&sourceStart),
+            reinterpret_cast<const UTF32*>(sourceEnd),
+            &targetStart, targetEnd, flags);
+    }
+    
+    static ConversionResult fromUTF8(
+        const Byte*& sourceStart, const Byte* sourceEnd, 
+        wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags)
+    {
+        return ConvertUTF8toUTF32(
+            &sourceStart, sourceEnd,
+            reinterpret_cast<UTF32**>(&targetStart),
+            reinterpret_cast<UTF32*>(targetEnd), flags);
+    }
+};
+}
+
+//
+// convertXXX functions
+//
+
+ConversionResult 
+IceUtilInternal::convertUTFWstringToUTF8(
+    const wchar_t*& sourceStart, const wchar_t* sourceEnd, 
+    Byte*& targetStart, Byte* targetEnd, ConversionFlags flags)
+{
+    return WstringHelper<sizeof(wchar_t)>::toUTF8(
+        sourceStart, sourceEnd, targetStart, targetEnd, flags);
+}
+
+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);
+}
+
+ConversionResult 
+IceUtilInternal::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd, 
+                                 std::wstring& target, ConversionFlags flags)
+{
+    //
+    // 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;
+}
+
+