zeroc-ice 3.7.10 → 3.8.0

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

@@ -1,130 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/ThreadException.h>
-
-using namespace std;
-
-IceUtil::ThreadSyscallException::ThreadSyscallException(const char* file, int line, int err ):
-    SyscallExceptionHelper<ThreadSyscallException>(file, line, err)
-{
-}
-
-string
-IceUtil::ThreadSyscallException::ice_id() const
-{
-    return "::IceUtil::ThreadSyscallException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::ThreadSyscallException*
-IceUtil::ThreadSyscallException::ice_clone() const
-{
-    return new ThreadSyscallException(*this);
-}
-#endif
-
-IceUtil::ThreadLockedException::ThreadLockedException(const char* file, int line) :
-    ExceptionHelper<ThreadLockedException>(file, line)
-{
-}
-
-string
-IceUtil::ThreadLockedException::ice_id() const
-{
-    return "::IceUtil::ThreadLockedException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::ThreadLockedException*
-IceUtil::ThreadLockedException::ice_clone() const
-{
-    return new ThreadLockedException(*this);
-}
-#endif
-
-IceUtil::ThreadStartedException::ThreadStartedException(const char* file, int line) :
-    ExceptionHelper<ThreadStartedException>(file, line)
-{
-}
-
-string
-IceUtil::ThreadStartedException::ice_id() const
-{
-    return "::IceUtil::ThreadStartedException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::ThreadStartedException*
-IceUtil::ThreadStartedException::ice_clone() const
-{
-    return new ThreadStartedException(*this);
-}
-#endif
-
-IceUtil::ThreadNotStartedException::ThreadNotStartedException(const char* file, int line) :
-    ExceptionHelper<ThreadNotStartedException>(file, line)
-{
-}
-
-string
-IceUtil::ThreadNotStartedException::ice_id() const
-{
-    return "::IceUtil::ThreadNotStartedException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::ThreadNotStartedException*
-IceUtil::ThreadNotStartedException::ice_clone() const
-{
-    return new ThreadNotStartedException(*this);
-}
-#endif
-
-IceUtil::BadThreadControlException::BadThreadControlException(const char* file, int line) :
-    ExceptionHelper<BadThreadControlException>(file, line)
-{
-}
-
-string
-IceUtil::BadThreadControlException::ice_id() const
-{
-    return "::IceUtil::BadThreadControlException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::BadThreadControlException*
-IceUtil::BadThreadControlException::ice_clone() const
-{
-    return new BadThreadControlException(*this);
-}
-#endif
-
-IceUtil::InvalidTimeoutException::InvalidTimeoutException(const char* file, int line,
-                                                          const IceUtil::Time& timeout) :
-    ExceptionHelper<InvalidTimeoutException>(file, line),
-    _timeout(timeout)
-{
-}
-
-string
-IceUtil::InvalidTimeoutException::ice_id() const
-{
-    return "::IceUtil::InvalidTimeoutException";
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::InvalidTimeoutException*
-IceUtil::InvalidTimeoutException::ice_clone() const
-{
-    return new InvalidTimeoutException(*this);
-}
-#endif
-
-void
-IceUtil::InvalidTimeoutException::ice_print(ostream& os) const
-{
-    Exception::ice_print(os);
-    os << ":\ninvalid timeout: " << _timeout << " seconds";
-}

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

@@ -1,307 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/DisableWarnings.h>
-#include <IceUtil/Exception.h>
-#include <IceUtil/Time.h>
-#include <iomanip>
-
-#ifdef _WIN32
-#   include <sys/timeb.h>
-#   include <time.h>
-#else
-#   include <sys/time.h>
-#endif
-
-#ifdef __APPLE__
-#   include <mach/mach.h>
-#   include <mach/mach_time.h>
-#endif
-
-using namespace IceUtil;
-
-#ifdef _WIN32
-
-namespace
-{
-
-double frequency = -1.0;
-
-//
-// Initialize the frequency
-//
-class InitializeFrequency
-{
-public:
-
-    InitializeFrequency()
-    {
-        //
-        // Get the frequency of performance counters. We also make a call to
-        // QueryPerformanceCounter to ensure it works. If it fails or if the
-        // call to QueryPerformanceFrequency fails, the frequency will remain
-        // set to -1.0 and ftime will be used instead.
-        //
-        Int64 v;
-        if(QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&v)))
-        {
-            if(QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&v)))
-            {
-                frequency = static_cast<double>(v);
-            }
-        }
-    }
-};
-InitializeFrequency frequencyInitializer;
-
-}
-#endif
-
-#if defined(__APPLE__)
-namespace
-{
-
-double machMultiplier = 1.0;
-class InitializeTime
-{
-public:
-
-    InitializeTime()
-    {
-        mach_timebase_info_data_t initTimeBase = { 0, 0 };
-        mach_timebase_info(&initTimeBase);
-        machMultiplier = static_cast<double>(initTimeBase.numer) / initTimeBase.denom / ICE_INT64(1000);
-    }
-};
-InitializeTime initializeTime;
-
-}
-#endif
-
-Time::Time() :
-    _usec(0)
-{
-}
-
-Time
-IceUtil::Time::now(Clock clock)
-{
-    if(clock == Realtime)
-    {
-#ifdef _WIN32
-#  if defined(_MSC_VER)
-        struct _timeb tb;
-        _ftime(&tb);
-#  elif defined(__MINGW32__)
-        struct timeb tb;
-        ftime(&tb);
-#  endif
-        return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + Int64(tb.millitm) * 1000);
-#else
-        struct timeval tv;
-        if(gettimeofday(&tv, 0) < 0)
-        {
-            assert(0);
-            throw SyscallException(__FILE__, __LINE__, errno);
-        }
-        return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
-#endif
-    }
-    else // Monotonic
-    {
-#if defined(_WIN32)
-        if(frequency > 0.0)
-        {
-            Int64 count;
-            if(!QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&count)))
-            {
-                assert(0);
-                throw SyscallException(__FILE__, __LINE__, GetLastError());
-            }
-            return Time(static_cast<Int64>(count / frequency * 1000000.0));
-        }
-        else
-        {
-#  if defined(_MSC_VER)
-            struct _timeb tb;
-            _ftime(&tb);
-#  elif defined(__MINGW32__)
-            struct timeb tb;
-            ftime(&tb);
-#  endif
-            return Time(static_cast<Int64>(tb.time) * ICE_INT64(1000000) + Int64(tb.millitm) * 1000);
-        }
-#elif defined(__hppa)
-        //
-        // HP does not support CLOCK_MONOTONIC
-        //
-        struct timeval tv;
-        if(gettimeofday(&tv, 0) < 0)
-        {
-            assert(0);
-            throw SyscallException(__FILE__, __LINE__, errno);
-        }
-        return Time(tv.tv_sec * ICE_INT64(1000000) + tv.tv_usec);
-#elif defined(__APPLE__)
-        return Time(static_cast<IceUtil::Int64>(mach_absolute_time() * machMultiplier));
-#else
-        struct timespec ts;
-        if(clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
-        {
-            assert(0);
-            throw SyscallException(__FILE__, __LINE__, errno);
-        }
-        return Time(ts.tv_sec * ICE_INT64(1000000) + ts.tv_nsec / ICE_INT64(1000));
-#endif
-    }
-}
-
-Time
-IceUtil::Time::seconds(Int64 t)
-{
-    return Time(t * ICE_INT64(1000000));
-}
-
-Time
-IceUtil::Time::milliSeconds(Int64 t)
-{
-    return Time(t * ICE_INT64(1000));
-}
-
-Time
-IceUtil::Time::microSeconds(Int64 t)
-{
-    return Time(t);
-}
-
-Time
-IceUtil::Time::secondsDouble(double t)
-{
-    return Time(Int64(t * 1000000));
-}
-
-Time
-IceUtil::Time::milliSecondsDouble(double t)
-{
-    return Time(Int64(t * 1000));
-}
-
-Time
-IceUtil::Time::microSecondsDouble(double t)
-{
-    return Time(Int64(t));
-}
-
-#ifndef _WIN32
-IceUtil::Time::operator timeval() const
-{
-    timeval tv;
-    tv.tv_sec = static_cast<time_t>(_usec / 1000000);
-    tv.tv_usec = static_cast<suseconds_t>(_usec % 1000000);
-    return tv;
-}
-#endif
-
-Int64
-IceUtil::Time::toSeconds() const
-{
-    return _usec / 1000000;
-}
-
-Int64
-IceUtil::Time::toMilliSeconds() const
-{
-    return _usec / 1000;
-}
-
-Int64
-IceUtil::Time::toMicroSeconds() const
-{
-    return _usec;
-}
-
-double
-IceUtil::Time::toSecondsDouble() const
-{
-    return _usec / 1000000.0;
-}
-
-double
-IceUtil::Time::toMilliSecondsDouble() const
-{
-    return _usec / 1000.0;
-}
-
-double
-IceUtil::Time::toMicroSecondsDouble() const
-{
-    return static_cast<double>(_usec);
-}
-
-std::string
-IceUtil::Time::toDateTime() const
-{
-    std::ostringstream os;
-    os << toString("%x %H:%M:%S") << ".";
-    os.fill('0');
-    os.width(3);
-    os << static_cast<Int64>(_usec % 1000000 / 1000);
-    return os.str();
-}
-
-std::string
-IceUtil::Time::toDuration() const
-{
-    Int64 usecs = _usec % 1000000;
-    Int64 secs = _usec / 1000000 % 60;
-    Int64 mins = _usec / 1000000 / 60 % 60;
-    Int64 hours = _usec / 1000000 / 60 / 60 % 24;
-    Int64 days = _usec / 1000000 / 60 / 60 / 24;
-
-    using namespace std;
-
-    ostringstream os;
-    if(days != 0)
-    {
-        os << days << "d ";
-    }
-    os << setfill('0') << setw(2) << hours << ":" << setw(2) << mins << ":" << setw(2) << secs;
-    if(usecs != 0)
-    {
-        os << "." << setw(3) << (usecs / 1000);
-    }
-
-    return os.str();
-}
-
-std::string
-IceUtil::Time::toString(const std::string& format) const
-{
-    time_t time = static_cast<time_t>(_usec / 1000000);
-
-    struct tm tr;
-#ifdef _MSC_VER
-    localtime_s(&tr, &time);
-#else
-    localtime_r(&time, &tr);
-#endif
-
-    char buf[32];
-    if(strftime(buf, sizeof(buf), format.c_str(), &tr) == 0)
-    {
-        return std::string();
-    }
-    return std::string(buf);
-}
-
-Time::Time(Int64 usec) :
-    _usec(usec)
-{
-}
-
-std::ostream&
-IceUtil::operator<<(std::ostream& out, const Time& tm)
-{
-    return out << tm.toMicroSeconds() / 1000000.0;
-}

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

@@ -1,165 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#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;
-
-#ifndef _WIN32
-
-namespace
-{
-
-char myPid[2];
-
-}
-
-namespace IceUtilInternal
-{
-
-//
-// Initialize the pid.
-//
-class PidInitializer
-{
-public:
-
-    PidInitializer()
-    {
-        pid_t p = getpid();
-        myPid[0] = (p >> 8) & 0x7F;
-        myPid[1] = static_cast<char>(p & 0xFF);
-    }
-};
-
-PidInitializer pidInitializer;
-
-};
-#endif
-
-namespace
-{
-
-// Helper char to hex functions
-//
-inline void halfByteToHex(unsigned char hb, char*& hexBuffer)
-{
-    if(hb < 10)
-    {
-        *hexBuffer++ = '0' + static_cast<char>(hb);
-    }
-    else
-    {
-        *hexBuffer++ = 'A' + static_cast<char>(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)
-
-    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 SyscallException(__FILE__, __LINE__, GetLastError());
-    }
-
-    unsigned char* str;
-
-    ret = UuidToString(&uuid, &str);
-    if(ret != RPC_S_OK)
-    {
-        throw 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) | static_cast<unsigned char>(myPid[0]);
-    uuid.node[5] = static_cast<unsigned char>(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
-}