zeroc-ice 3.7.9.1 → 3.7.11

data/dist/ice/cpp/include/IceUtil/IceUtil.h

@@ -0,0 +1,40 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_ICE_UTIL_H
+#define ICE_UTIL_ICE_UTIL_H
+
+#include <IceUtil/PushDisableWarnings.h>
+
+//
+// This file must include *all* headers of IceUtil, except
+// for DisableWarnings.h and headers with only IceUtilInternal symbols
+//
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Cond.h>
+#include <IceUtil/ConsoleUtil.h>
+#if !defined(__APPLE__) || TARGET_OS_IPHONE == 0
+#   include <IceUtil/CtrlCHandler.h>
+#endif
+#include <IceUtil/Exception.h>
+#include <IceUtil/Functional.h>
+#include <IceUtil/Handle.h>
+#include <IceUtil/Lock.h>
+#include <IceUtil/Monitor.h>
+#include <IceUtil/MutexProtocol.h>
+#include <IceUtil/Mutex.h>
+#include <IceUtil/MutexPtrLock.h>
+#include <IceUtil/RecMutex.h>
+#include <IceUtil/ScopedArray.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/StringConverter.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/ThreadException.h>
+#include <IceUtil/Time.h>
+#include <IceUtil/Timer.h>
+#include <IceUtil/UUID.h>
+
+#include <IceUtil/PopDisableWarnings.h>
+#endif

data/dist/ice/cpp/include/IceUtil/InputUtil.h

@@ -0,0 +1,42 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_INPUT_UTIL_H
+#define ICE_UTIL_INPUT_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <string>
+
+namespace IceUtilInternal
+{
+
+//
+// Portable strtoll/_strtoi64
+//
+ICE_API IceUtil::Int64 strToInt64(const char*, char**, int);
+
+//
+// stringToInt64 converts a string into a signed 64-bit integer.
+// It's a simple wrapper around strToInt64.
+//
+// Semantics:
+//
+// - Ignore leading whitespace
+//
+// - If the string starts with '0', parse as octal
+//
+// - If the string starts with "0x" or "0X", parse as hexadecimal
+//
+// - Otherwise, parse as decimal
+//
+// - return value == true indicates a successful conversion and result contains the converted value
+// - return value == false indicates an unsuccessful conversion:
+//      - result == 0 indicates that no digits were available for conversion
+//      - result == "Int64 Min" or result == "Int64 Max" indicate underflow or overflow.
+//
+ICE_API bool stringToInt64(const std::string&, IceUtil::Int64&);
+
+}
+
+#endif

data/dist/ice/cpp/include/IceUtil/Mutex.h

@@ -0,0 +1,349 @@
+
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_MUTEX_H
+#define ICE_UTIL_MUTEX_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Lock.h>
+#include <IceUtil/ThreadException.h>
+#include <IceUtil/MutexProtocol.h>
+
+namespace IceUtil
+{
+
+//
+// Forward declaration for friend.
+//
+class Cond;
+
+//
+// Simple non-recursive Mutex implementation.
+//
+// Don't use noncopyable otherwise you end up with warnings like this:
+//
+// In file included from Connection.cpp:20:
+// ../../include/Ice/Outgoing.h:88: warning: direct base
+// `IceUtil::noncopyable' inaccessible in `IceInternal::Outgoing' due
+// to ambiguity
+//
+class ICE_API Mutex
+{
+public:
+
+    //
+    // Lock & TryLock typedefs.
+    //
+    typedef LockT<Mutex> Lock;
+    typedef TryLockT<Mutex> TryLock;
+
+    inline Mutex();
+    inline Mutex(MutexProtocol);
+    ~Mutex();
+
+    //
+    // Note that lock/tryLock & unlock in general should not be used
+    // directly. Instead use Lock & TryLock.
+    //
+
+    void lock() const;
+
+    //
+    // Returns true if the lock was acquired, and false otherwise.
+    //
+    bool tryLock() const;
+
+    void unlock() const;
+
+    //
+    // Returns true if the mutex will unlock when calling unlock()
+    // (false otherwise). For non-recursive mutexes, this will always
+    // return true.
+    // This function is used by the Monitor implementation to know whether
+    // the Mutex has been locked for the first time, or unlocked for the
+    // last time (that is another thread is able to acquire the mutex).
+    // Pre-condition: the mutex must be locked.
+    //
+    bool willUnlock() const;
+
+private:
+
+    inline void init(MutexProtocol);
+    // noncopyable
+    Mutex(const Mutex&);
+    void operator=(const Mutex&);
+
+    //
+    // LockState and the lock/unlock variations are for use by the
+    // Condition variable implementation.
+    //
+#ifdef _WIN32
+    struct LockState
+    {
+#   ifdef ICE_HAS_WIN32_CONDVAR
+        CRITICAL_SECTION* mutex;
+#   endif
+    };
+#else
+    struct LockState
+    {
+        pthread_mutex_t* mutex;
+    };
+#endif
+
+    void unlock(LockState&) const;
+    void lock(LockState&) const;
+
+    friend class Cond;
+
+#ifdef _WIN32
+    mutable CRITICAL_SECTION _mutex;
+#else
+    mutable pthread_mutex_t _mutex;
+#endif
+};
+
+//
+// For performance reasons the following functions are inlined.
+//
+inline
+Mutex::Mutex()
+{
+#ifdef _WIN32
+    init(PrioNone);
+#else
+    init(getDefaultMutexProtocol());
+#endif
+}
+
+#ifdef _WIN32
+inline
+Mutex::Mutex(MutexProtocol)
+{
+    init(PrioNone);
+}
+#else
+inline
+Mutex::Mutex(MutexProtocol protocol)
+{
+    init(protocol);
+}
+#endif
+
+#ifdef _WIN32
+
+inline void
+Mutex::init(MutexProtocol)
+{
+    InitializeCriticalSection(&_mutex);
+}
+
+inline
+Mutex::~Mutex()
+{
+    DeleteCriticalSection(&_mutex);
+}
+
+inline void
+Mutex::lock() const
+{
+    EnterCriticalSection(&_mutex);
+#ifndef NDEBUG
+    if(_mutex.RecursionCount > 1)
+    {
+        LeaveCriticalSection(&_mutex);
+        throw ThreadLockedException(__FILE__, __LINE__);
+    }
+#endif
+}
+
+inline bool
+Mutex::tryLock() const
+{
+    if(!TryEnterCriticalSection(&_mutex))
+    {
+        return false;
+    }
+    if(_mutex.RecursionCount > 1)
+    {
+        LeaveCriticalSection(&_mutex);
+        throw ThreadLockedException(__FILE__, __LINE__);
+    }
+    return true;
+}
+
+inline void
+Mutex::unlock() const
+{
+    assert(_mutex.RecursionCount == 1);
+    LeaveCriticalSection(&_mutex);
+}
+
+#  ifdef ICE_HAS_WIN32_CONDVAR
+inline void
+Mutex::unlock(LockState& state) const
+{
+    state.mutex = &_mutex;
+}
+
+inline void
+Mutex::lock(LockState&) const
+{
+}
+#  else
+inline void
+Mutex::unlock(LockState&) const
+{
+    LeaveCriticalSection(&_mutex);
+}
+
+inline void
+Mutex::lock(LockState&) const
+{
+    EnterCriticalSection(&_mutex);
+}
+#   endif
+
+#else
+
+inline void
+Mutex::init(MutexProtocol
+#if defined(_POSIX_THREAD_PRIO_INHERIT) && _POSIX_THREAD_PRIO_INHERIT > 0
+            protocol
+#endif
+            )
+{
+    int rc;
+    pthread_mutexattr_t attr;
+    rc = pthread_mutexattr_init(&attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+    //
+    // Enable mutex error checking
+    //
+    rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+    //
+    // If system has support for priority inheritance we set the protocol
+    // attribute of the mutex
+    //
+#if defined(_POSIX_THREAD_PRIO_INHERIT) && _POSIX_THREAD_PRIO_INHERIT > 0
+    if(PrioInherit == protocol)
+    {
+        rc = pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
+        if(rc != 0)
+        {
+            pthread_mutexattr_destroy(&attr);
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+#endif
+
+    rc = pthread_mutex_init(&_mutex, &attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        pthread_mutexattr_destroy(&attr);
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+
+    rc = pthread_mutexattr_destroy(&attr);
+    assert(rc == 0);
+    if(rc != 0)
+    {
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+}
+
+inline
+Mutex::~Mutex()
+{
+#ifndef NDEBUG
+    int rc = 0;
+    rc = pthread_mutex_destroy(&_mutex);
+    assert(rc == 0);
+#else
+    pthread_mutex_destroy(&_mutex);
+#endif
+}
+
+inline void
+Mutex::lock() const
+{
+    int rc = pthread_mutex_lock(&_mutex);
+    if(rc != 0)
+    {
+        if(rc == EDEADLK)
+        {
+            throw ThreadLockedException(__FILE__, __LINE__);
+        }
+        else
+        {
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+}
+
+inline bool
+Mutex::tryLock() const
+{
+    int rc = pthread_mutex_trylock(&_mutex);
+    if(rc != 0 && rc != EBUSY)
+    {
+        if(rc == EDEADLK)
+        {
+            throw ThreadLockedException(__FILE__, __LINE__);
+        }
+        else
+        {
+            throw ThreadSyscallException(__FILE__, __LINE__, rc);
+        }
+    }
+    return (rc == 0);
+}
+
+inline void
+Mutex::unlock() const
+{
+    int rc = pthread_mutex_unlock(&_mutex);
+    if(rc != 0)
+    {
+        throw ThreadSyscallException(__FILE__, __LINE__, rc);
+    }
+}
+
+inline void
+Mutex::unlock(LockState& state) const
+{
+    state.mutex = &_mutex;
+}
+
+inline void
+Mutex::lock(LockState&) const
+{
+}
+
+#endif
+
+inline bool
+Mutex::willUnlock() const
+{
+    return true;
+}
+
+} // End namespace IceUtil
+
+#endif

data/dist/ice/cpp/include/IceUtil/ResourceConfig.h

@@ -0,0 +1,37 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_RESOURCE_CONFIG_H
+#define ICE_UTIL_RESOURCE_CONFIG_H
+
+#include "winver.h"
+
+#define ICE_VERSION 3,7,11,0
+#define ICE_STRING_VERSION "3.7.11\0"
+#define ICE_SO_VERSION "37\0"
+#define ICE_COMPANY_NAME "ZeroC, Inc.\0"
+#define ICE_COPYRIGHT "\251 ZeroC, Inc.\0"
+#define ICE_PRODUCT_NAME "Ice\0"
+
+#ifdef ICE_CPP11_MAPPING
+#   if defined(_DEBUG)
+#       define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION "++11D"
+#   else
+#      define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION "++11"
+#  endif
+#else
+#  if defined(_DEBUG)
+#      define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION "D"
+#  else
+#      define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION ""
+#  endif
+#endif
+
+#ifndef DEBUG
+#  define VER_DEBUG 0
+#else
+#  define VER_DEBUG VS_FF_DEBUG
+#endif
+
+#endif

data/dist/ice/cpp/include/IceUtil/Thread.h

@@ -0,0 +1,160 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_THREAD_H
+#define ICE_UTIL_THREAD_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+#include <IceUtil/Mutex.h>
+
+namespace IceUtil
+{
+
+class Time;
+
+class ICE_API ThreadControl
+{
+public:
+
+    //
+    // Constructs a ThreadControl representing the current thread.
+    // join and detach cannot be called on such ThreadControl object.
+    //
+    ThreadControl();
+
+#if defined(_WIN32)
+    ThreadControl(HANDLE, DWORD);
+#else
+    explicit ThreadControl(pthread_t);
+#endif
+
+    //
+    // Default copy destructor, assignment operator and destructor OK
+    //
+
+    //
+    // == and != are meaningful only before the thread is joined/detached,
+    // or while the thread is still running.
+    //
+    bool operator==(const ThreadControl&) const;
+    bool operator!=(const ThreadControl&) const;
+
+    //
+    // Wait until the controlled thread terminates. The call has POSIX
+    // semantics.
+    //
+    // At most one thread can wait for the termination of a given
+    // thread. Calling join on a thread on which another thread is
+    // already waiting for termination results in undefined behaviour,
+    // as does joining with a thread after having joined with it
+    // previously, or joining with a detached thread.
+    //
+    void join();
+
+    //
+    // Detach a thread. Once a thread is detached, it cannot be
+    // detached again, nor can it be joined with. Every thread that
+    // was created using the IceUtil::Thread class must either be
+    // joined with or detached exactly once. Detaching a thread a
+    // second time, or detaching a thread that was previously joined
+    // with results in undefined behavior.
+    //
+    void detach();
+
+    //
+    // id() returns the Thread ID on Windows and the underlying pthread_t
+    // on POSIX platforms.
+    //
+#if defined(_WIN32)
+    typedef DWORD ID;
+#else
+    typedef pthread_t ID;
+#endif
+    ID id() const;
+
+    static void sleep(const Time&);
+    static void yield();
+
+private:
+
+#if defined(_WIN32)
+    HANDLE _handle;
+    DWORD  _id;
+#else
+    pthread_t _thread;
+
+    //
+    // Used to prevent joining/detaching a ThreadControl constructed
+    // with the default constructor. Only needed to enforce our
+    // portable join/detach behavior.
+    //
+    bool _detachable;
+#endif
+};
+
+class ICE_API Thread : public virtual IceUtil::Shared
+{
+public:
+
+    Thread();
+    Thread(const std::string&);
+    virtual ~Thread();
+
+    virtual void run() = 0;
+
+    ThreadControl start(size_t = 0);
+    ThreadControl start(size_t, int priority);
+
+    ThreadControl getThreadControl() const;
+
+    bool operator==(const Thread&) const;
+    bool operator<(const Thread&) const;
+
+    //
+    // Check whether a thread is still alive.
+    //
+    bool isAlive() const;
+
+    //
+    // This function is an implementation detail;
+    // do not call it.
+    //
+    void _done();
+
+    //
+    // Get the thread name
+    //
+    const std::string& name() const;
+
+protected:
+    const std::string _name;
+    Mutex _stateMutex;
+    bool _started;
+    bool _running;
+
+#if defined(_WIN32)
+    HANDLE _handle;
+    DWORD  _id;
+#else
+    pthread_t _thread;
+#endif
+
+private:
+
+#ifdef _WIN32
+#else
+    ThreadControl start(size_t, bool, int);
+#endif
+
+    Thread(const Thread&);              // Copying is forbidden
+    void operator=(const Thread&);      // Assignment is forbidden
+};
+
+typedef Handle<Thread> ThreadPtr;
+
+}
+
+#endif