zeroc-ice 3.6b1

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

@@ -0,0 +1,47 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_INPUT_UTIL_H
+#define ICE_UTIL_INPUT_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <string>
+
+namespace IceUtilInternal
+{
+
+//
+// Portable strtoll/_strtoi64
+//
+ICE_UTIL_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_UTIL_API  bool stringToInt64(const std::string&, IceUtil::Int64&);
+
+}
+
+#endif

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

@@ -0,0 +1,36 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_ITERATOR_H
+#define ICE_UTIL_ITERATOR_H
+
+#include <iterator>
+
+namespace IceUtilInternal
+{
+
+template<class ForwardIterator>
+inline typename ForwardIterator::difference_type
+distance(ForwardIterator first, ForwardIterator last)
+{
+//
+// Work-around for a limitation in the standard library provided 
+// with the Sun C++ 5.x compilers
+#if defined(__SUNPRO_CC) && defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
+
+    ForwardIterator::difference_type result = 0;
+    std::distance(first, last, result);
+    return result;
+#else
+    return ::std::distance(first, last);
+#endif
+}
+
+}
+#endif

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

@@ -0,0 +1,135 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_LOCK_H
+#define ICE_UTIL_LOCK_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/ThreadException.h>
+
+namespace IceUtil
+{
+
+//
+// Forward declarations.
+//
+class Cond;
+
+
+// LockT and TryLockT are the preferred construct to lock/tryLock/unlock
+// simple and recursive mutexes. You typically allocate them on the
+// stack to hold a lock on a mutex.
+// LockT and TryLockT are not recursive: you cannot acquire several times 
+// in a row a lock with the same Lock or TryLock object.
+// 
+// We must name this LockT instead of Lock, because otherwise some
+// compilers (such as Sun C++ 5.4) have problems with constructs
+// such as:
+//
+// class Foo
+// {
+//     // ...
+//     typedef Lock<Mutex> Lock;
+// }
+//
+template <typename T>
+class LockT
+{
+public:
+    
+    LockT(const T& mutex) :
+        _mutex(mutex)
+    {
+        _mutex.lock();
+        _acquired = true;
+    }
+
+    ~LockT()
+    {
+        if (_acquired)
+        {
+            _mutex.unlock();
+        }
+    }
+    
+    void acquire() const
+    {
+        if (_acquired)
+        {
+            throw ThreadLockedException(__FILE__, __LINE__);
+        }
+        _mutex.lock();
+        _acquired = true;
+    }
+
+
+    bool tryAcquire() const
+    {
+        if (_acquired)
+        {
+            throw ThreadLockedException(__FILE__, __LINE__);
+        }
+        _acquired = _mutex.tryLock();
+        return _acquired;
+    }
+
+    void release() const
+    {
+        if (!_acquired)
+        {
+            throw ThreadLockedException(__FILE__, __LINE__);
+        }
+        _mutex.unlock();
+        _acquired = false;
+    }
+
+    bool acquired() const
+    {
+        return _acquired;
+    }
+   
+protected:
+    
+    // TryLockT's contructor
+    LockT(const T& mutex, bool) :
+        _mutex(mutex)
+    {
+        _acquired = _mutex.tryLock();
+    }
+
+private:
+    
+    // Not implemented; prevents accidental use.
+    //
+    LockT(const LockT&);
+    LockT& operator=(const LockT&);
+
+    const T& _mutex;
+    mutable bool _acquired;
+
+    friend class Cond;
+};
+
+//
+// Must be named TryLockT, not TryLock. See the comment for LockT for
+// an explanation.
+//
+template <typename T>
+class TryLockT : public LockT<T>
+{
+public:
+
+    TryLockT(const T& mutex) :
+        LockT<T>(mutex, true)
+    {}
+};
+
+} // End namespace IceUtil
+
+#endif

data/ext/ice/cpp/include/IceUtil/Makefile

@@ -0,0 +1,26 @@
+# **********************************************************************
+#
+# 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.
+#
+# **********************************************************************
+
+top_srcdir	= ../..
+
+include $(top_srcdir)/config/Make.rules
+
+install::
+	@if test ! -d $(DESTDIR)$(install_includedir)/IceUtil ; \
+	then \
+	    echo "Creating $(DESTDIR)$(install_includedir)/IceUtil..." ; \
+	    $(call mkdir,$(DESTDIR)$(install_includedir)/IceUtil) ; \
+	fi
+
+	@for i in *.h ; \
+	do \
+	    echo "Installing $$i" ; \
+	    $(INSTALL_DATA) $$i $(DESTDIR)$(install_includedir)/IceUtil/$$i ; \
+	    chmod a+r $(DESTDIR)$(install_includedir)/IceUtil/$$i ; \
+	done

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

@@ -0,0 +1,249 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_MONITOR_H
+#define ICE_UTIL_MONITOR_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Lock.h>
+#include <IceUtil/Cond.h>
+
+namespace IceUtil
+{
+
+//
+// This monitor implements the Mesa monitor semantics. That is any
+// calls to notify() or notifyAll() are delayed until the monitor is
+// unlocked.
+//
+template <class T>
+class Monitor
+{
+public:
+
+    typedef LockT<Monitor<T> > Lock;
+    typedef TryLockT<Monitor<T> > TryLock;
+
+    Monitor();
+    ~Monitor();
+
+    //
+    // Note that lock/tryLock & unlock in general should not be used
+    // directly. Instead use Lock & TryLock.
+    //
+    void lock() const;
+    void unlock() const;
+    bool tryLock() const;
+
+    void wait() const;
+    bool timedWait(const Time&) const;
+    void notify();
+    void notifyAll();
+
+private:
+
+    // noncopyable
+    Monitor(const Monitor&);
+    void operator=(const Monitor&);
+
+    void notifyImpl(int) const;
+
+    mutable Cond _cond;
+    T _mutex;
+    mutable int _nnotify;
+};
+
+} // End namespace IceUtil
+
+//
+// Since this monitor implements the Mesa monitor semantics calls to
+// notify() or notifyAll() are delayed until the monitor is
+// unlocked. This can happen either due to a call to unlock(), or a
+// call to wait(). The _nnotify flag keeps track of the number of
+// pending notification calls. -1 indicates a broadcast, a positive
+// number indicates <n> calls to notify(). The _nnotify flag is reset
+// upon initial acquisition of the monitor lock (either through a call
+// to lock(), or a return from wait().
+//
+
+template <class T> inline
+IceUtil::Monitor<T>::Monitor() :
+    _nnotify(0)
+{
+}
+
+template <class T> inline
+IceUtil::Monitor<T>::~Monitor()
+{
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::lock() const
+{
+    _mutex.lock();
+    if(_mutex.willUnlock())
+    {
+        //
+        // On the first mutex acquisition reset the number pending
+        // notifications.
+        //
+        _nnotify = 0;
+    }
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::unlock() const
+{
+    if(_mutex.willUnlock())
+    {
+        //
+        // Perform any pending notifications.
+        //
+        notifyImpl(_nnotify);
+    }
+    _mutex.unlock();
+
+/*
+    int nnotify = _nnotify;
+    if(_mutex.unlock())
+    {
+        //
+        // Perform any pending notifications.
+        //
+        notifyImpl(nnotify);
+    }
+*/
+}
+
+template <class T> inline bool
+IceUtil::Monitor<T>::tryLock() const
+{
+    bool result = _mutex.tryLock();
+    if(result && _mutex.willUnlock())
+    {
+        //
+        // On the first mutex acquisition reset the number pending
+        // notifications.
+        //
+        _nnotify = 0;
+    }
+    return result;
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::wait() const
+{
+    //
+    // Perform any pending notifies
+    //
+    notifyImpl(_nnotify);
+
+    //
+    // Wait for a notification
+    //
+    try
+    {
+        _cond.waitImpl(_mutex);
+        //
+        // Reset the nnotify count once wait() returns.
+        //
+    }
+    catch(...)
+    {
+        _nnotify = 0;
+        throw;
+    }
+
+    _nnotify = 0;
+}
+
+template <class T> inline bool
+IceUtil::Monitor<T>::timedWait(const Time& timeout) const
+{
+    //
+    // Perform any pending notifies.
+    //
+    notifyImpl(_nnotify);
+
+    bool rc;
+    //
+    // Wait for a notification.
+    //
+    try
+    {
+        rc = _cond.timedWaitImpl(_mutex, timeout);
+
+        //
+        // Reset the nnotify count once wait() returns.
+        //
+    }
+    catch(...)
+    {
+        _nnotify = 0;
+        throw;
+    }
+
+    _nnotify = 0;
+    return rc;
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::notify()
+{
+    //
+    // Increment the _nnotify flag, unless a broadcast has already
+    // been requested.
+    //
+    if(_nnotify != -1)
+    {
+        ++_nnotify;
+    }
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::notifyAll()
+{
+    //
+    // -1 (indicates broadcast)
+    //
+    _nnotify = -1;
+}
+
+
+template <class T> inline void
+IceUtil::Monitor<T>::notifyImpl(int nnotify) const
+{
+    //
+    // Zero indicates no notifies.
+    //
+    if(nnotify != 0)
+    {
+        //
+        // -1 means notifyAll.
+        //
+        if(nnotify == -1)
+        {
+            _cond.broadcast();
+            return;
+        }
+        else
+        {
+            //
+            // Otherwise notify n times.
+            //
+            while(nnotify > 0)
+            {
+                _cond.signal();
+                --nnotify;
+            }
+        }
+    }
+}
+
+#endif