summaryrefslogtreecommitdiff
path: root/cpp/include/IceUtil
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/include/IceUtil')
-rw-r--r--cpp/include/IceUtil/Base64.h76
-rw-r--r--cpp/include/IceUtil/Cond.h668
-rw-r--r--cpp/include/IceUtil/Config.h288
-rw-r--r--cpp/include/IceUtil/Exception.h106
-rw-r--r--cpp/include/IceUtil/Functional.h906
-rw-r--r--cpp/include/IceUtil/Handle.h462
-rw-r--r--cpp/include/IceUtil/IceUtil.h64
-rw-r--r--cpp/include/IceUtil/InputUtil.h130
-rw-r--r--cpp/include/IceUtil/Lock.h144
-rw-r--r--cpp/include/IceUtil/Monitor.h470
-rw-r--r--cpp/include/IceUtil/Mutex.h500
-rw-r--r--cpp/include/IceUtil/OutputUtil.h650
-rw-r--r--cpp/include/IceUtil/RWRecMutex.h512
-rw-r--r--cpp/include/IceUtil/RecMutex.h224
-rw-r--r--cpp/include/IceUtil/Shared.h728
-rw-r--r--cpp/include/IceUtil/Thread.h234
-rw-r--r--cpp/include/IceUtil/ThreadException.h94
-rw-r--r--cpp/include/IceUtil/Time.h126
-rw-r--r--cpp/include/IceUtil/UUID.h46
-rw-r--r--cpp/include/IceUtil/Unicode.h48
20 files changed, 3238 insertions, 3238 deletions
diff --git a/cpp/include/IceUtil/Base64.h b/cpp/include/IceUtil/Base64.h
index 3e1dc03e8ee..a4563e4cb8e 100644
--- a/cpp/include/IceUtil/Base64.h
+++ b/cpp/include/IceUtil/Base64.h
@@ -1,38 +1,38 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_BASE_64_H
-#define ICE_UTIL_BASE_64_H
-
-#include <IceUtil/Config.h>
-#include <string>
-#include <vector>
-
-namespace IceUtil
-{
-
-class ICE_UTIL_API Base64
-{
-public:
-
- static std::string encode(const std::vector<char>&);
- static std::vector<char> decode(const std::string&);
-
-
-private:
-
- static char encode(unsigned char);
- static unsigned char decode(char);
- static bool isBase64(char);
-};
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_BASE_64_H
+#define ICE_UTIL_BASE_64_H
+
+#include <IceUtil/Config.h>
+#include <string>
+#include <vector>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API Base64
+{
+public:
+
+ static std::string encode(const std::vector<char>&);
+ static std::vector<char> decode(const std::string&);
+
+
+private:
+
+ static char encode(unsigned char);
+ static unsigned char decode(char);
+ static bool isBase64(char);
+};
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Cond.h b/cpp/include/IceUtil/Cond.h
index c9ad5036ae3..88647bc4d3d 100644
--- a/cpp/include/IceUtil/Cond.h
+++ b/cpp/include/IceUtil/Cond.h
@@ -1,334 +1,334 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_COND_H
-#define ICE_UTIL_COND_H
-
-#include <IceUtil/Config.h>
-#include <IceUtil/Time.h>
-#include <IceUtil/ThreadException.h>
-
-#ifdef _WIN32
-//
-// Needed for implementation under WIN32.
-//
-# include <IceUtil/Mutex.h>
-//
-// See member-template note for waitImpl & timedWaitImpl.
-//
-# include <IceUtil/RecMutex.h>
-#endif
-
-namespace IceUtil
-{
-
-//
-// Forward declaration (for friend declarations).
-//
-template <class T> class Monitor;
-class RecMutex;
-class Mutex;
-
-#ifdef _WIN32
-//
-// Needed for implementation.
-//
-class Semaphore
-{
-public:
-
- Semaphore(long = 0);
- ~Semaphore();
-
- void wait() const;
- bool timedWait(const Time&) const;
- void post(int = 1) const;
-
-private:
-
- mutable HANDLE _sem;
-};
-#endif
-
-//
-// Condition variable implementation. Conforms to the same semantics
-// as a POSIX threads condition variable.
-//
-class ICE_UTIL_API Cond : public noncopyable
-{
-public:
-
- Cond();
- ~Cond();
-
- //
- // signal restarts one of the threads that are waiting on the
- // condition variable cond. If no threads are waiting on cond,
- // nothing happens. If several threads are waiting on cond,
- // exactly one is restarted, but it is not specified which.
- //
- void signal();
-
- //
- // broadcast restarts all the threads that are waiting on the
- // condition variable cond. Nothing happens if no threads are
- // waiting on cond.
- //
- void broadcast();
-
- //
- // MSVC doesn't support out-of-class definitions of member
- // templates. See KB Article Q241949 for details.
- //
-
- //
- // wait atomically unlocks the mutex and waits for the condition
- // variable to be signaled. Before returning to the calling thread
- // the mutex is reaquired.
- //
- template <typename Lock> inline void
- wait(const Lock& lock) const
- {
- waitImpl(lock._mutex);
- }
-
- //
- // wait atomically unlocks the mutex and waits for the condition
- // variable to be signaled for up to the given timeout. Before
- // returning to the calling thread the mutex is reaquired. Returns
- // true if the condition variable was signaled, false on a
- // timeout.
- //
- template <typename Lock> inline bool
- timedWait(const Lock& lock, const Time& timeout) const
- {
- return timedWaitImpl(lock._mutex, timeout);
- }
-
-private:
-
- friend class Monitor<Mutex>;
- friend class Monitor<RecMutex>;
-
- //
- // The Monitor implementation uses waitImpl & timedWaitImpl.
- //
-#ifdef _WIN32
-
- //
- // For some reason under WIN32 with VC6 using a member-template
- // for waitImpl & timedWaitImpl results in a link error for
- // RecMutex.
- //
-/*
- template <typename M> void
- waitImpl(const M& mutex) const
- {
- preWait();
-
- typedef typename M::LockState LockState;
-
- LockState state;
- mutex.unlock(state);
-
- try
- {
- dowait(-1);
- mutex.lock(state);
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
- template <typename M> bool
- timedWaitImpl(const M& mutex, const Time& timeout) const
- {
- preWait();
-
- typedef typename M::LockState LockState;
-
- LockState state;
- mutex.unlock(state);
-
- try
- {
- bool rc = dowait(timeout);
- mutex.lock(state);
- return rc;
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
- */
-
- void
- waitImpl(const RecMutex& mutex) const
- {
- preWait();
-
- RecMutex::LockState state;
- mutex.unlock(state);
-
- try
- {
- dowait();
- mutex.lock(state);
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
-
- void
- waitImpl(const Mutex& mutex) const
- {
- preWait();
-
- Mutex::LockState state;
- mutex.unlock(state);
-
- try
- {
- dowait();
- mutex.lock(state);
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
-
- bool
- timedWaitImpl(const RecMutex& mutex, const Time& timeout) const
- {
- preWait();
-
- RecMutex::LockState state;
- mutex.unlock(state);
-
- try
- {
- bool rc = timedDowait(timeout);
- mutex.lock(state);
- return rc;
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
-
- bool
- timedWaitImpl(const Mutex& mutex, const Time& timeout) const
- {
- preWait();
-
- Mutex::LockState state;
- mutex.unlock(state);
-
- try
- {
- bool rc = timedDowait(timeout);
- mutex.lock(state);
- return rc;
- }
- catch(...)
- {
- mutex.lock(state);
- throw;
- }
- }
-
-#else
-
- template <typename M> void waitImpl(const M&) const;
- template <typename M> bool timedWaitImpl(const M&, const Time&) const;
-
-#endif
-
-#ifdef _WIN32
- void wake(bool);
- void preWait() const;
- void postWait(bool) const;
- bool timedDowait(const Time&) const;
- void dowait() const;
-
- Mutex _internal;
- Semaphore _gate;
- Semaphore _queue;
- mutable long _blocked;
- mutable long _unblocked;
- mutable long _toUnblock;
-#else
- mutable pthread_cond_t _cond;
-#endif
-
-};
-
-#ifndef _WIN32
-template <typename M> inline void
-Cond::waitImpl(const M& mutex) const
-{
- typedef typename M::LockState LockState;
-
- LockState state;
- mutex.unlock(state);
- int rc = pthread_cond_wait(&_cond, state.mutex);
- mutex.lock(state);
-
- if(rc != 0)
- {
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
-}
-
-template <typename M> inline bool
-Cond::timedWaitImpl(const M& mutex, const Time& timeout) const
-{
- typedef typename M::LockState LockState;
-
- LockState state;
- mutex.unlock(state);
-
- timeval tv = Time::now() + timeout;
- timespec ts;
- ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = tv.tv_usec*1000;
- int rc = pthread_cond_timedwait(&_cond, state.mutex, &ts);
- mutex.lock(state);
-
- if(rc != 0)
- {
- //
- // pthread_cond_timedwait returns ETIMEOUT in the event of a
- // timeout.
- //
- if(rc != ETIMEDOUT)
- {
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
- return false;
- }
- return true;
-}
-#endif
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_COND_H
+#define ICE_UTIL_COND_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Time.h>
+#include <IceUtil/ThreadException.h>
+
+#ifdef _WIN32
+//
+// Needed for implementation under WIN32.
+//
+# include <IceUtil/Mutex.h>
+//
+// See member-template note for waitImpl & timedWaitImpl.
+//
+# include <IceUtil/RecMutex.h>
+#endif
+
+namespace IceUtil
+{
+
+//
+// Forward declaration (for friend declarations).
+//
+template <class T> class Monitor;
+class RecMutex;
+class Mutex;
+
+#ifdef _WIN32
+//
+// Needed for implementation.
+//
+class Semaphore
+{
+public:
+
+ Semaphore(long = 0);
+ ~Semaphore();
+
+ void wait() const;
+ bool timedWait(const Time&) const;
+ void post(int = 1) const;
+
+private:
+
+ mutable HANDLE _sem;
+};
+#endif
+
+//
+// Condition variable implementation. Conforms to the same semantics
+// as a POSIX threads condition variable.
+//
+class ICE_UTIL_API Cond : public noncopyable
+{
+public:
+
+ Cond();
+ ~Cond();
+
+ //
+ // signal restarts one of the threads that are waiting on the
+ // condition variable cond. If no threads are waiting on cond,
+ // nothing happens. If several threads are waiting on cond,
+ // exactly one is restarted, but it is not specified which.
+ //
+ void signal();
+
+ //
+ // broadcast restarts all the threads that are waiting on the
+ // condition variable cond. Nothing happens if no threads are
+ // waiting on cond.
+ //
+ void broadcast();
+
+ //
+ // MSVC doesn't support out-of-class definitions of member
+ // templates. See KB Article Q241949 for details.
+ //
+
+ //
+ // wait atomically unlocks the mutex and waits for the condition
+ // variable to be signaled. Before returning to the calling thread
+ // the mutex is reaquired.
+ //
+ template <typename Lock> inline void
+ wait(const Lock& lock) const
+ {
+ waitImpl(lock._mutex);
+ }
+
+ //
+ // wait atomically unlocks the mutex and waits for the condition
+ // variable to be signaled for up to the given timeout. Before
+ // returning to the calling thread the mutex is reaquired. Returns
+ // true if the condition variable was signaled, false on a
+ // timeout.
+ //
+ template <typename Lock> inline bool
+ timedWait(const Lock& lock, const Time& timeout) const
+ {
+ return timedWaitImpl(lock._mutex, timeout);
+ }
+
+private:
+
+ friend class Monitor<Mutex>;
+ friend class Monitor<RecMutex>;
+
+ //
+ // The Monitor implementation uses waitImpl & timedWaitImpl.
+ //
+#ifdef _WIN32
+
+ //
+ // For some reason under WIN32 with VC6 using a member-template
+ // for waitImpl & timedWaitImpl results in a link error for
+ // RecMutex.
+ //
+/*
+ template <typename M> void
+ waitImpl(const M& mutex) const
+ {
+ preWait();
+
+ typedef typename M::LockState LockState;
+
+ LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ dowait(-1);
+ mutex.lock(state);
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+ template <typename M> bool
+ timedWaitImpl(const M& mutex, const Time& timeout) const
+ {
+ preWait();
+
+ typedef typename M::LockState LockState;
+
+ LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ bool rc = dowait(timeout);
+ mutex.lock(state);
+ return rc;
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+ */
+
+ void
+ waitImpl(const RecMutex& mutex) const
+ {
+ preWait();
+
+ RecMutex::LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ dowait();
+ mutex.lock(state);
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+
+ void
+ waitImpl(const Mutex& mutex) const
+ {
+ preWait();
+
+ Mutex::LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ dowait();
+ mutex.lock(state);
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+
+ bool
+ timedWaitImpl(const RecMutex& mutex, const Time& timeout) const
+ {
+ preWait();
+
+ RecMutex::LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ bool rc = timedDowait(timeout);
+ mutex.lock(state);
+ return rc;
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+
+ bool
+ timedWaitImpl(const Mutex& mutex, const Time& timeout) const
+ {
+ preWait();
+
+ Mutex::LockState state;
+ mutex.unlock(state);
+
+ try
+ {
+ bool rc = timedDowait(timeout);
+ mutex.lock(state);
+ return rc;
+ }
+ catch(...)
+ {
+ mutex.lock(state);
+ throw;
+ }
+ }
+
+#else
+
+ template <typename M> void waitImpl(const M&) const;
+ template <typename M> bool timedWaitImpl(const M&, const Time&) const;
+
+#endif
+
+#ifdef _WIN32
+ void wake(bool);
+ void preWait() const;
+ void postWait(bool) const;
+ bool timedDowait(const Time&) const;
+ void dowait() const;
+
+ Mutex _internal;
+ Semaphore _gate;
+ Semaphore _queue;
+ mutable long _blocked;
+ mutable long _unblocked;
+ mutable long _toUnblock;
+#else
+ mutable pthread_cond_t _cond;
+#endif
+
+};
+
+#ifndef _WIN32
+template <typename M> inline void
+Cond::waitImpl(const M& mutex) const
+{
+ typedef typename M::LockState LockState;
+
+ LockState state;
+ mutex.unlock(state);
+ int rc = pthread_cond_wait(&_cond, state.mutex);
+ mutex.lock(state);
+
+ if(rc != 0)
+ {
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+}
+
+template <typename M> inline bool
+Cond::timedWaitImpl(const M& mutex, const Time& timeout) const
+{
+ typedef typename M::LockState LockState;
+
+ LockState state;
+ mutex.unlock(state);
+
+ timeval tv = Time::now() + timeout;
+ timespec ts;
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec*1000;
+ int rc = pthread_cond_timedwait(&_cond, state.mutex, &ts);
+ mutex.lock(state);
+
+ if(rc != 0)
+ {
+ //
+ // pthread_cond_timedwait returns ETIMEOUT in the event of a
+ // timeout.
+ //
+ if(rc != ETIMEDOUT)
+ {
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+ return false;
+ }
+ return true;
+}
+#endif
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/Config.h b/cpp/include/IceUtil/Config.h
index 81c63eb07a6..d555854f10c 100644
--- a/cpp/include/IceUtil/Config.h
+++ b/cpp/include/IceUtil/Config.h
@@ -1,144 +1,144 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_CONFIG_H
-#define ICE_UTIL_CONFIG_H
-
-//
-// For STLport. If we compile in debug mode, we want to use the debug
-// STLport library. This is done by setting _STLP_DEBUG before any
-// STLport header files are included.
-//
-# if !defined(NDEBUG) && !defined(_STLP_DEBUG)
-# define _STLP_DEBUG
-# endif
-
-//
-// For STLport. If we compile in debug mode, we want to use the debug
-// memory allocation, so that purify doesn't report bogus memory
-// leaks. This is done by setting _STLP_USE_MALLOC before any STLport
-// header files are included.
-//
-# if !defined(NDEBUG) && !defined(_STLP_USE_MALLOC)
-# define _STLP_USE_MALLOC
-# endif
-
-#if defined(_WIN32)
-
-// Necessary for TryEnterCriticalSection.
-# define _WIN32_WINNT 0x0400
-
-# if !defined(_UNICODE)
-# error "Only unicode libraries can be used with Ice!"
-# endif
-
-# if !defined(_DLL) || !defined(_MT)
-# error "Only multi-threaded DLL libraries can be used with Ice!"
-# endif
-
-# ifdef ICE_UTIL_API_EXPORTS
-# define ICE_UTIL_API __declspec(dllexport)
-# else
-# define ICE_UTIL_API __declspec(dllimport)
-# endif
-
-# include <windows.h>
-
-// '...' : forcing value to bool 'true' or 'false' (performance warning)
-# pragma warning( disable : 4800 )
-// ... identifier was truncated to '255' characters in the debug information
-# pragma warning( disable : 4786 )
-// 'this' : used in base member initializer list
-# pragma warning( disable : 4355 )
-// class ... needs to have dll-interface to be used by clients of class ...
-# pragma warning( disable : 4251 )
-// ... : inherits ... via dominance
-# pragma warning( disable : 4250 )
-// non dll-interface class ... used as base for dll-interface class ...
-# pragma warning( disable : 4275 )
-// ...: decorated name length exceeded, name was truncated
-# pragma warning( disable : 4503 )
-
-# define SIZEOF_WCHAR_T 2
-
-#elif defined(__linux__) && defined(i386)
-
-# define ICE_UTIL_API /**/
-# define HAVE_READLINE
-# define SIZEOF_WCHAR_T 4
-
-#else
-
-# error "unsupported operating system or platform"
-
-#endif
-
-//
-// Some include files we need almost everywhere
-//
-#include <cassert>
-#include <iostream>
-#include <sstream>
-
-#ifndef _WIN32
-# ifndef _REENTRANT
-# define _REENTRANT 1
-# endif
-# include <pthread.h>
-# include <errno.h>
-#endif
-
-//
-// By deriving from this class, other classes are made non-copyable
-//
-namespace IceUtil
-{
-
-//
-// TODO: Constructor and destructor should not be inlined, as they are
-// not performance critical.
-//
-// TODO: Naming conventions?
-//
-class noncopyable
-{
-protected:
-
- noncopyable() { }
- ~noncopyable() { } // May not be virtual! Classes without virtual operations also derive from noncopyable.
-
-private:
-
- noncopyable(const noncopyable&);
- const noncopyable& operator=(const noncopyable&);
-};
-//
-//
-// Some definitions for 64-bit integers
-//
-#if defined(_WIN32)
- typedef __int64 Int64;
- const Int64 Int64Min = -9223372036854775808i64;
- const Int64 Int64Max = 9223372036854775807i64;
-#elif defined(__linux__) && defined(i386)
- typedef long long Int64;
- const Int64 Int64Min = LONGLONG_MIN;
- const Int64 Int64Max = LONGLONG_MAX;
-#endif
-
-}
-
-//
-// The Ice version
-//
-#define ICE_STRING_VERSION "0.0.1"
-#define ICE_INT_VERSION 0x00000001
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_CONFIG_H
+#define ICE_UTIL_CONFIG_H
+
+//
+// For STLport. If we compile in debug mode, we want to use the debug
+// STLport library. This is done by setting _STLP_DEBUG before any
+// STLport header files are included.
+//
+# if !defined(NDEBUG) && !defined(_STLP_DEBUG)
+# define _STLP_DEBUG
+# endif
+
+//
+// For STLport. If we compile in debug mode, we want to use the debug
+// memory allocation, so that purify doesn't report bogus memory
+// leaks. This is done by setting _STLP_USE_MALLOC before any STLport
+// header files are included.
+//
+# if !defined(NDEBUG) && !defined(_STLP_USE_MALLOC)
+# define _STLP_USE_MALLOC
+# endif
+
+#if defined(_WIN32)
+
+// Necessary for TryEnterCriticalSection.
+# define _WIN32_WINNT 0x0400
+
+# if !defined(_UNICODE)
+# error "Only unicode libraries can be used with Ice!"
+# endif
+
+# if !defined(_DLL) || !defined(_MT)
+# error "Only multi-threaded DLL libraries can be used with Ice!"
+# endif
+
+# ifdef ICE_UTIL_API_EXPORTS
+# define ICE_UTIL_API __declspec(dllexport)
+# else
+# define ICE_UTIL_API __declspec(dllimport)
+# endif
+
+# include <windows.h>
+
+// '...' : forcing value to bool 'true' or 'false' (performance warning)
+# pragma warning( disable : 4800 )
+// ... identifier was truncated to '255' characters in the debug information
+# pragma warning( disable : 4786 )
+// 'this' : used in base member initializer list
+# pragma warning( disable : 4355 )
+// class ... needs to have dll-interface to be used by clients of class ...
+# pragma warning( disable : 4251 )
+// ... : inherits ... via dominance
+# pragma warning( disable : 4250 )
+// non dll-interface class ... used as base for dll-interface class ...
+# pragma warning( disable : 4275 )
+// ...: decorated name length exceeded, name was truncated
+# pragma warning( disable : 4503 )
+
+# define SIZEOF_WCHAR_T 2
+
+#elif defined(__linux__) && defined(i386)
+
+# define ICE_UTIL_API /**/
+# define HAVE_READLINE
+# define SIZEOF_WCHAR_T 4
+
+#else
+
+# error "unsupported operating system or platform"
+
+#endif
+
+//
+// Some include files we need almost everywhere
+//
+#include <cassert>
+#include <iostream>
+#include <sstream>
+
+#ifndef _WIN32
+# ifndef _REENTRANT
+# define _REENTRANT 1
+# endif
+# include <pthread.h>
+# include <errno.h>
+#endif
+
+//
+// By deriving from this class, other classes are made non-copyable
+//
+namespace IceUtil
+{
+
+//
+// TODO: Constructor and destructor should not be inlined, as they are
+// not performance critical.
+//
+// TODO: Naming conventions?
+//
+class noncopyable
+{
+protected:
+
+ noncopyable() { }
+ ~noncopyable() { } // May not be virtual! Classes without virtual operations also derive from noncopyable.
+
+private:
+
+ noncopyable(const noncopyable&);
+ const noncopyable& operator=(const noncopyable&);
+};
+//
+//
+// Some definitions for 64-bit integers
+//
+#if defined(_WIN32)
+ typedef __int64 Int64;
+ const Int64 Int64Min = -9223372036854775808i64;
+ const Int64 Int64Max = 9223372036854775807i64;
+#elif defined(__linux__) && defined(i386)
+ typedef long long Int64;
+ const Int64 Int64Min = LONGLONG_MIN;
+ const Int64 Int64Max = LONGLONG_MAX;
+#endif
+
+}
+
+//
+// The Ice version
+//
+#define ICE_STRING_VERSION "0.0.1"
+#define ICE_INT_VERSION 0x00000001
+
+#endif
diff --git a/cpp/include/IceUtil/Exception.h b/cpp/include/IceUtil/Exception.h
index c694cceea23..ee544ec4138 100644
--- a/cpp/include/IceUtil/Exception.h
+++ b/cpp/include/IceUtil/Exception.h
@@ -1,53 +1,53 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_EXCEPTION_H
-#define ICE_UTIL_EXCEPTION_H
-
-#include <IceUtil/Config.h>
-
-namespace IceUtil
-{
-
-class ICE_UTIL_API Exception
-{
-public:
-
- Exception();
- Exception(const char*, int);
- virtual ~Exception();
- virtual std::string ice_name() const;
- virtual void ice_print(std::ostream&) const;
- virtual Exception* ice_clone() const;
- virtual void ice_throw() const;
- const char* ice_file() const;
- int ice_line() const;
-
-private:
-
- const char* _file;
- int _line;
-};
-
-ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Exception&);
-
-class ICE_UTIL_API NullHandleException : public Exception
-{
-public:
-
- NullHandleException(const char*, int);
- virtual std::string ice_name() const;
- virtual Exception* ice_clone() const;
- virtual void ice_throw() const;
-};
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_EXCEPTION_H
+#define ICE_UTIL_EXCEPTION_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API Exception
+{
+public:
+
+ Exception();
+ Exception(const char*, int);
+ virtual ~Exception();
+ virtual std::string ice_name() const;
+ virtual void ice_print(std::ostream&) const;
+ virtual Exception* ice_clone() const;
+ virtual void ice_throw() const;
+ const char* ice_file() const;
+ int ice_line() const;
+
+private:
+
+ const char* _file;
+ int _line;
+};
+
+ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Exception&);
+
+class ICE_UTIL_API NullHandleException : public Exception
+{
+public:
+
+ NullHandleException(const char*, int);
+ virtual std::string ice_name() const;
+ virtual Exception* ice_clone() const;
+ virtual void ice_throw() const;
+};
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Functional.h b/cpp/include/IceUtil/Functional.h
index 57b0df17243..bf8b4ceac65 100644
--- a/cpp/include/IceUtil/Functional.h
+++ b/cpp/include/IceUtil/Functional.h
@@ -1,453 +1,453 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_FUNCTIONAL_H
-#define ICE_UTIL_FUNCTIONAL_H
-
-#include <IceUtil/Handle.h>
-#include <functional>
-
-namespace IceUtilInternal
-{
-
-// ----------------------------------------------------------------------
-// Various function objects that work with handles instead of plain
-// pointers.
-// ----------------------------------------------------------------------
-
-template<class R, class T, class H>
-class MemFun : public std::unary_function<H, R>
-{
- typedef R (T::*MemberFN)(void);
- MemberFN _mfn;
-
-public:
-
- explicit MemFun(MemberFN p) : _mfn(p) { }
- R operator()(H handle) const
- {
- return (handle.get() ->* _mfn)();
- }
-};
-
-template<class R, class T, class H, class A>
-class MemFun1 : public std::binary_function<H, A, R>
-{
- typedef R (T::*MemberFN)(A);
- MemberFN _mfn;
-
-public:
-
- explicit MemFun1(MemberFN p) : _mfn(p) { }
- R operator()(H handle, A arg) const
- {
- return (handle.get() ->* _mfn)(arg);
- }
-};
-
-template<class T, class H>
-class VoidMemFun : public std::unary_function<H, void>
-{
- typedef void (T::*MemberFN)(void);
- MemberFN _mfn;
-
-public:
-
- explicit VoidMemFun(MemberFN p) : _mfn(p) { }
- void operator()(H handle) const
- {
- (handle.get() ->* _mfn)();
- }
-};
-
-template<class T, class H, class A>
-class VoidMemFun1 : public std::binary_function<H, A, void>
-{
- typedef void (T::*MemberFN)(A);
- MemberFN _mfn;
-
-public:
-
- explicit VoidMemFun1(MemberFN p) : _mfn(p) { }
- void operator()(H handle, A arg) const
- {
- (handle.get() ->* _mfn)(arg);
- }
-};
-
-template<class R, class K, class T, class H>
-class SecondMemFun : public std::unary_function<std::pair<K, H>, R>
-{
- typedef R (T::*MemberFN)(void);
- MemberFN _mfn;
-
-public:
-
- explicit SecondMemFun(MemberFN p) : _mfn(p) { }
- R operator()(std::pair<K, H> pair) const
- {
- return (pair.second.get() ->* _mfn)();
- }
-};
-
-template<class R, class K, class T, class H, class A>
-class SecondMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
-{
- typedef R (T::*MemberFN)(A);
- MemberFN _mfn;
-
-public:
-
- explicit SecondMemFun1(MemberFN p) : _mfn(p) { }
- R operator()(std::pair<K, H> pair, A arg) const
- {
- return (pair.second.get() ->* _mfn)(arg);
- }
-};
-
-template<class K, class T, class H>
-class SecondVoidMemFun : public std::unary_function<std::pair<K, H>, void>
-{
- typedef void (T::*MemberFN)(void);
- MemberFN _mfn;
-
-public:
-
- explicit SecondVoidMemFun(MemberFN p) : _mfn(p) { }
- void operator()(std::pair<K, H> pair) const
- {
- (pair.second.get() ->* _mfn)();
- }
-};
-
-template<class K, class T, class H, class A>
-class SecondVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
-{
- typedef void (T::*MemberFN)(A);
- MemberFN _mfn;
-
-public:
-
- explicit SecondVoidMemFun1(MemberFN p) : _mfn(p) { }
- void operator()(std::pair<K, H> pair, A arg) const
- {
- (pair.second.get() ->* _mfn)(arg);
- }
-};
-
-template<class R, class T, class H>
-class ConstMemFun : public std::unary_function<H, R>
-{
- typedef R (T::*MemberFN)(void) const;
- MemberFN _mfn;
-
-public:
-
- explicit ConstMemFun(MemberFN p) : _mfn(p) { }
- R operator()(H handle) const
- {
- return (handle.get() ->* _mfn)();
- }
-};
-
-template<class R, class T, class H, class A>
-class ConstMemFun1 : public std::binary_function<H, A, R>
-{
- typedef R (T::*MemberFN)(A) const;
- MemberFN _mfn;
-
-public:
-
- explicit ConstMemFun1(MemberFN p) : _mfn(p) { }
- R operator()(H handle, A arg) const
- {
- return (handle.get() ->* _mfn)(arg);
- }
-};
-
-template<class T, class H>
-class ConstVoidMemFun : public std::unary_function<H, void>
-{
- typedef void (T::*MemberFN)(void) const;
- MemberFN _mfn;
-
-public:
-
- explicit ConstVoidMemFun(MemberFN p) : _mfn(p) { }
- void operator()(H handle) const
- {
- (handle.get() ->* _mfn)();
- }
-};
-
-template<class T, class H, class A>
-class ConstVoidMemFun1 : public std::binary_function<H, A, void>
-{
- typedef void (T::*MemberFN)(A) const;
- MemberFN _mfn;
-
-public:
-
- explicit ConstVoidMemFun1(MemberFN p) : _mfn(p) { }
- void operator()(H handle, A arg) const
- {
- (handle.get() ->* _mfn)(arg);
- }
-};
-
-template<class R, class K, class T, class H>
-class SecondConstMemFun : public std::unary_function<std::pair<K, H>, R>
-{
- typedef R (T::*MemberFN)(void) const;
- MemberFN _mfn;
-
-public:
-
- explicit SecondConstMemFun(MemberFN p) : _mfn(p) { }
- R operator()(std::pair<K, H> pair) const
- {
- return (pair.second.get() ->* _mfn)();
- }
-};
-
-template<class R, class K, class T, class H, class A>
-class SecondConstMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
-{
- typedef R (T::*MemberFN)(A) const;
- MemberFN _mfn;
-
-public:
-
- explicit SecondConstMemFun1(MemberFN p) : _mfn(p) { }
- R operator()(std::pair<K, H> pair, A arg) const
- {
- return (pair.second.get() ->* _mfn)(arg);
- }
-};
-
-template<class K, class T, class H>
-class SecondConstVoidMemFun : public std::unary_function<std::pair<K, H>, void>
-{
- typedef void (T::*MemberFN)(void) const;
- MemberFN _mfn;
-
-public:
-
- explicit SecondConstVoidMemFun(MemberFN p) : _mfn(p) { }
- void operator()(std::pair<K, H> pair) const
- {
- (pair.second.get() ->* _mfn)();
- }
-};
-
-template<class K, class T, class H, class A>
-class SecondConstVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
-{
- typedef void (T::*MemberFN)(A) const;
- MemberFN _mfn;
-
-public:
-
- explicit SecondConstVoidMemFun1(MemberFN p) : _mfn(p) { }
- void operator()(std::pair<K, H> pair, A arg) const
- {
- (pair.second.get() ->* _mfn)(arg);
- }
-};
-
-}
-
-// ----------------------------------------------------------------------
-// Inline functions that return function objects that work with
-// IceUtil::Handle
-// ----------------------------------------------------------------------
-
-namespace IceUtil
-{
-
-template<class R, class T>
-inline ::IceUtilInternal::MemFun<R, T, Handle<T> >
-memFun(R (T::*p)(void))
-{
- return ::IceUtilInternal::MemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>
-memFun1(R (T::*p)(A))
-{
- return ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::VoidMemFun<T, Handle<T> >
-voidMemFun(void (T::*p)(void))
-{
- return ::IceUtilInternal::VoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>
-voidMemFun1(void (T::*p)(A))
-{
- return ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >
-secondMemFun(R (T::*p)(void))
-{
- return ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>
-secondMemFun1(R (T::*p)(A))
-{
- return ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >
-secondVoidMemFun(void (T::*p)(void))
-{
- return ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
-secondVoidMemFun1(void (T::*p)(A))
-{
- return ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-template<class R, class T>
-inline ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >
-constMemFun(R (T::*p)(void) const)
-{
- return ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >(p);
-}
-
-template<class R, class T, class A>
-inline ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>
-constMemFun1(R (T::*p)(A) const)
-{
- return ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
-}
-
-template<class T>
-inline ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >
-constVoidMemFun(void (T::*p)(void) const)
-{
- return ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >(p);
-}
-
-template<class T, class A>
-inline ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>
-constVoidMemFun1(void (T::*p)(A) const)
-{
- return ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
-}
-
-template<class R, class K, class T>
-inline ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >
-secondConstMemFun(R (T::*p)(void) const)
-{
- return ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
-}
-
-template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
-secondConstMemFun1(R (T::*p)(A) const)
-{
- return ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
-}
-
-template<class K, class T>
-inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >
-secondConstVoidMemFun(void (T::*p)(void) const)
-{
- return ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
-}
-
-template<class K, class T, class A>
-inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
-secondConstVoidMemFun1(void (T::*p)(A) const)
-{
- return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
-}
-
-}
-
-// ----------------------------------------------------------------------
-// Extension for STLport: Special versions for bind1st and bind2nd for
-// operations that do not return anything (i.e., return void). Needed
-// for broken compilers, such as Visual C++
-// ----------------------------------------------------------------------
-
-#ifdef _STLP_BEGIN_NAMESPACE
-
-_STLP_BEGIN_NAMESPACE
-
-template <class _Operation>
-class voidbinder1st :
- public unary_function<typename __BINARY_ARG(_Operation,second_argument_type),
- typename __BINARY_ARG(_Operation,result_type) > {
-protected:
- _Operation _M_op;
- typename _Operation::first_argument_type _M_value;
-public:
- voidbinder1st(const _Operation& __x,
- const typename _Operation::first_argument_type& __y)
- : _M_op(__x), _M_value(__y) {}
- typename _Operation::result_type
- operator()(const typename _Operation::second_argument_type& __x) const {
- _M_op(_M_value, __x);
- }
-};
-
-template <class _Operation, class _Tp>
-inline voidbinder1st<_Operation>
-voidbind1st(const _Operation& __fn, const _Tp& __x)
-{
- typedef typename _Operation::first_argument_type _Arg1_type;
- return voidbinder1st<_Operation>(__fn, _Arg1_type(__x));
-}
-
-template <class _Operation>
-class voidbinder2nd
- : public unary_function<typename __BINARY_ARG(_Operation,first_argument_type),
- typename __BINARY_ARG(_Operation,result_type)> {
-protected:
- _Operation _M_op;
- typename _Operation::second_argument_type value;
-public:
- voidbinder2nd(const _Operation& __x,
- const typename _Operation::second_argument_type& __y)
- : _M_op(__x), value(__y) {}
- typename _Operation::result_type
- operator()(const typename _Operation::first_argument_type& __x) const {
- _M_op(__x, value);
- }
-};
-
-template <class _Operation, class _Tp>
-inline voidbinder2nd<_Operation>
-voidbind2nd(const _Operation& __fn, const _Tp& __x)
-{
- typedef typename _Operation::second_argument_type _Arg2_type;
- return voidbinder2nd<_Operation>(__fn, _Arg2_type(__x));
-}
-
-_STLP_END_NAMESPACE
-
-#endif
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_FUNCTIONAL_H
+#define ICE_UTIL_FUNCTIONAL_H
+
+#include <IceUtil/Handle.h>
+#include <functional>
+
+namespace IceUtilInternal
+{
+
+// ----------------------------------------------------------------------
+// Various function objects that work with handles instead of plain
+// pointers.
+// ----------------------------------------------------------------------
+
+template<class R, class T, class H>
+class MemFun : public std::unary_function<H, R>
+{
+ typedef R (T::*MemberFN)(void);
+ MemberFN _mfn;
+
+public:
+
+ explicit MemFun(MemberFN p) : _mfn(p) { }
+ R operator()(H handle) const
+ {
+ return (handle.get() ->* _mfn)();
+ }
+};
+
+template<class R, class T, class H, class A>
+class MemFun1 : public std::binary_function<H, A, R>
+{
+ typedef R (T::*MemberFN)(A);
+ MemberFN _mfn;
+
+public:
+
+ explicit MemFun1(MemberFN p) : _mfn(p) { }
+ R operator()(H handle, A arg) const
+ {
+ return (handle.get() ->* _mfn)(arg);
+ }
+};
+
+template<class T, class H>
+class VoidMemFun : public std::unary_function<H, void>
+{
+ typedef void (T::*MemberFN)(void);
+ MemberFN _mfn;
+
+public:
+
+ explicit VoidMemFun(MemberFN p) : _mfn(p) { }
+ void operator()(H handle) const
+ {
+ (handle.get() ->* _mfn)();
+ }
+};
+
+template<class T, class H, class A>
+class VoidMemFun1 : public std::binary_function<H, A, void>
+{
+ typedef void (T::*MemberFN)(A);
+ MemberFN _mfn;
+
+public:
+
+ explicit VoidMemFun1(MemberFN p) : _mfn(p) { }
+ void operator()(H handle, A arg) const
+ {
+ (handle.get() ->* _mfn)(arg);
+ }
+};
+
+template<class R, class K, class T, class H>
+class SecondMemFun : public std::unary_function<std::pair<K, H>, R>
+{
+ typedef R (T::*MemberFN)(void);
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondMemFun(MemberFN p) : _mfn(p) { }
+ R operator()(std::pair<K, H> pair) const
+ {
+ return (pair.second.get() ->* _mfn)();
+ }
+};
+
+template<class R, class K, class T, class H, class A>
+class SecondMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
+{
+ typedef R (T::*MemberFN)(A);
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondMemFun1(MemberFN p) : _mfn(p) { }
+ R operator()(std::pair<K, H> pair, A arg) const
+ {
+ return (pair.second.get() ->* _mfn)(arg);
+ }
+};
+
+template<class K, class T, class H>
+class SecondVoidMemFun : public std::unary_function<std::pair<K, H>, void>
+{
+ typedef void (T::*MemberFN)(void);
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondVoidMemFun(MemberFN p) : _mfn(p) { }
+ void operator()(std::pair<K, H> pair) const
+ {
+ (pair.second.get() ->* _mfn)();
+ }
+};
+
+template<class K, class T, class H, class A>
+class SecondVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
+{
+ typedef void (T::*MemberFN)(A);
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondVoidMemFun1(MemberFN p) : _mfn(p) { }
+ void operator()(std::pair<K, H> pair, A arg) const
+ {
+ (pair.second.get() ->* _mfn)(arg);
+ }
+};
+
+template<class R, class T, class H>
+class ConstMemFun : public std::unary_function<H, R>
+{
+ typedef R (T::*MemberFN)(void) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit ConstMemFun(MemberFN p) : _mfn(p) { }
+ R operator()(H handle) const
+ {
+ return (handle.get() ->* _mfn)();
+ }
+};
+
+template<class R, class T, class H, class A>
+class ConstMemFun1 : public std::binary_function<H, A, R>
+{
+ typedef R (T::*MemberFN)(A) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit ConstMemFun1(MemberFN p) : _mfn(p) { }
+ R operator()(H handle, A arg) const
+ {
+ return (handle.get() ->* _mfn)(arg);
+ }
+};
+
+template<class T, class H>
+class ConstVoidMemFun : public std::unary_function<H, void>
+{
+ typedef void (T::*MemberFN)(void) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit ConstVoidMemFun(MemberFN p) : _mfn(p) { }
+ void operator()(H handle) const
+ {
+ (handle.get() ->* _mfn)();
+ }
+};
+
+template<class T, class H, class A>
+class ConstVoidMemFun1 : public std::binary_function<H, A, void>
+{
+ typedef void (T::*MemberFN)(A) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit ConstVoidMemFun1(MemberFN p) : _mfn(p) { }
+ void operator()(H handle, A arg) const
+ {
+ (handle.get() ->* _mfn)(arg);
+ }
+};
+
+template<class R, class K, class T, class H>
+class SecondConstMemFun : public std::unary_function<std::pair<K, H>, R>
+{
+ typedef R (T::*MemberFN)(void) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondConstMemFun(MemberFN p) : _mfn(p) { }
+ R operator()(std::pair<K, H> pair) const
+ {
+ return (pair.second.get() ->* _mfn)();
+ }
+};
+
+template<class R, class K, class T, class H, class A>
+class SecondConstMemFun1 : public std::binary_function<std::pair<K, H>, A, R>
+{
+ typedef R (T::*MemberFN)(A) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondConstMemFun1(MemberFN p) : _mfn(p) { }
+ R operator()(std::pair<K, H> pair, A arg) const
+ {
+ return (pair.second.get() ->* _mfn)(arg);
+ }
+};
+
+template<class K, class T, class H>
+class SecondConstVoidMemFun : public std::unary_function<std::pair<K, H>, void>
+{
+ typedef void (T::*MemberFN)(void) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondConstVoidMemFun(MemberFN p) : _mfn(p) { }
+ void operator()(std::pair<K, H> pair) const
+ {
+ (pair.second.get() ->* _mfn)();
+ }
+};
+
+template<class K, class T, class H, class A>
+class SecondConstVoidMemFun1 : public std::binary_function<std::pair<K, H>, A, void>
+{
+ typedef void (T::*MemberFN)(A) const;
+ MemberFN _mfn;
+
+public:
+
+ explicit SecondConstVoidMemFun1(MemberFN p) : _mfn(p) { }
+ void operator()(std::pair<K, H> pair, A arg) const
+ {
+ (pair.second.get() ->* _mfn)(arg);
+ }
+};
+
+}
+
+// ----------------------------------------------------------------------
+// Inline functions that return function objects that work with
+// IceUtil::Handle
+// ----------------------------------------------------------------------
+
+namespace IceUtil
+{
+
+template<class R, class T>
+inline ::IceUtilInternal::MemFun<R, T, Handle<T> >
+memFun(R (T::*p)(void))
+{
+ return ::IceUtilInternal::MemFun<R, T, Handle<T> >(p);
+}
+
+template<class R, class T, class A>
+inline ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>
+memFun1(R (T::*p)(A))
+{
+ return ::IceUtilInternal::MemFun1<R, T, Handle<T>, A>(p);
+}
+
+template<class T>
+inline ::IceUtilInternal::VoidMemFun<T, Handle<T> >
+voidMemFun(void (T::*p)(void))
+{
+ return ::IceUtilInternal::VoidMemFun<T, Handle<T> >(p);
+}
+
+template<class T, class A>
+inline ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>
+voidMemFun1(void (T::*p)(A))
+{
+ return ::IceUtilInternal::VoidMemFun1<T, Handle<T>, A>(p);
+}
+
+template<class R, class K, class T>
+inline ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >
+secondMemFun(R (T::*p)(void))
+{
+ return ::IceUtilInternal::SecondMemFun<R, K, T, Handle<T> >(p);
+}
+
+template<class R, class K, class T, class A>
+inline ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>
+secondMemFun1(R (T::*p)(A))
+{
+ return ::IceUtilInternal::SecondMemFun1<R, K, T, Handle<T>, A>(p);
+}
+
+template<class K, class T>
+inline ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >
+secondVoidMemFun(void (T::*p)(void))
+{
+ return ::IceUtilInternal::SecondVoidMemFun<K, T, Handle<T> >(p);
+}
+
+template<class K, class T, class A>
+inline ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>
+secondVoidMemFun1(void (T::*p)(A))
+{
+ return ::IceUtilInternal::SecondVoidMemFun1<K, T, Handle<T>, A>(p);
+}
+
+template<class R, class T>
+inline ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >
+constMemFun(R (T::*p)(void) const)
+{
+ return ::IceUtilInternal::ConstMemFun<R, T, Handle<T> >(p);
+}
+
+template<class R, class T, class A>
+inline ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>
+constMemFun1(R (T::*p)(A) const)
+{
+ return ::IceUtilInternal::ConstMemFun1<R, T, Handle<T>, A>(p);
+}
+
+template<class T>
+inline ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >
+constVoidMemFun(void (T::*p)(void) const)
+{
+ return ::IceUtilInternal::ConstVoidMemFun<T, Handle<T> >(p);
+}
+
+template<class T, class A>
+inline ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>
+constVoidMemFun1(void (T::*p)(A) const)
+{
+ return ::IceUtilInternal::ConstVoidMemFun1<T, Handle<T>, A>(p);
+}
+
+template<class R, class K, class T>
+inline ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >
+secondConstMemFun(R (T::*p)(void) const)
+{
+ return ::IceUtilInternal::SecondConstMemFun<R, K, T, Handle<T> >(p);
+}
+
+template<class R, class K, class T, class A>
+inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>
+secondConstMemFun1(R (T::*p)(A) const)
+{
+ return ::IceUtilInternal::SecondConstMemFun1<R, K, T, Handle<T>, A>(p);
+}
+
+template<class K, class T>
+inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >
+secondConstVoidMemFun(void (T::*p)(void) const)
+{
+ return ::IceUtilInternal::SecondConstVoidMemFun<K, T, Handle<T> >(p);
+}
+
+template<class K, class T, class A>
+inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>
+secondConstVoidMemFun1(void (T::*p)(A) const)
+{
+ return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, Handle<T>, A>(p);
+}
+
+}
+
+// ----------------------------------------------------------------------
+// Extension for STLport: Special versions for bind1st and bind2nd for
+// operations that do not return anything (i.e., return void). Needed
+// for broken compilers, such as Visual C++
+// ----------------------------------------------------------------------
+
+#ifdef _STLP_BEGIN_NAMESPACE
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Operation>
+class voidbinder1st :
+ public unary_function<typename __BINARY_ARG(_Operation,second_argument_type),
+ typename __BINARY_ARG(_Operation,result_type) > {
+protected:
+ _Operation _M_op;
+ typename _Operation::first_argument_type _M_value;
+public:
+ voidbinder1st(const _Operation& __x,
+ const typename _Operation::first_argument_type& __y)
+ : _M_op(__x), _M_value(__y) {}
+ typename _Operation::result_type
+ operator()(const typename _Operation::second_argument_type& __x) const {
+ _M_op(_M_value, __x);
+ }
+};
+
+template <class _Operation, class _Tp>
+inline voidbinder1st<_Operation>
+voidbind1st(const _Operation& __fn, const _Tp& __x)
+{
+ typedef typename _Operation::first_argument_type _Arg1_type;
+ return voidbinder1st<_Operation>(__fn, _Arg1_type(__x));
+}
+
+template <class _Operation>
+class voidbinder2nd
+ : public unary_function<typename __BINARY_ARG(_Operation,first_argument_type),
+ typename __BINARY_ARG(_Operation,result_type)> {
+protected:
+ _Operation _M_op;
+ typename _Operation::second_argument_type value;
+public:
+ voidbinder2nd(const _Operation& __x,
+ const typename _Operation::second_argument_type& __y)
+ : _M_op(__x), value(__y) {}
+ typename _Operation::result_type
+ operator()(const typename _Operation::first_argument_type& __x) const {
+ _M_op(__x, value);
+ }
+};
+
+template <class _Operation, class _Tp>
+inline voidbinder2nd<_Operation>
+voidbind2nd(const _Operation& __fn, const _Tp& __x)
+{
+ typedef typename _Operation::second_argument_type _Arg2_type;
+ return voidbinder2nd<_Operation>(__fn, _Arg2_type(__x));
+}
+
+_STLP_END_NAMESPACE
+
+#endif
+
+#endif
diff --git a/cpp/include/IceUtil/Handle.h b/cpp/include/IceUtil/Handle.h
index de901a65835..b9b625ac1bd 100644
--- a/cpp/include/IceUtil/Handle.h
+++ b/cpp/include/IceUtil/Handle.h
@@ -1,231 +1,231 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_HANDLE_H
-#define ICE_UTIL_HANDLE_H
-
-#include <IceUtil/Exception.h>
-#include <algorithm>
-
-//
-// "Handle" or "smart pointer" class for classes derived from
-// IceUtil::Shared or IceUtil::SimpleShared.
-//
-namespace IceUtil
-{
-
-template<typename T>
-class HandleBase
-{
-public:
-
- typedef T element_type;
-
- T* get() const
- {
- return _ptr;
- }
-
- T* operator->() const
- {
- if(!_ptr)
- {
- throw NullHandleException(__FILE__, __LINE__);
- }
-
- return _ptr;
- }
-
- operator bool() const
- {
- return _ptr ? true : false;
- }
-
- void swap(HandleBase& other)
- {
- std::swap(_ptr, other._ptr);
- }
-
- T* _ptr;
-};
-
-template<typename T, typename U>
-inline bool operator==(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
-{
- T* l = lhs.get();
- U* r = rhs.get();
- if(l && r)
- {
- return *l == *r;
- }
- else
- {
- return !l && !r;
- }
-}
-
-template<typename T, typename U>
-inline bool operator!=(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
-{
- T* l = lhs.get();
- U* r = rhs.get();
- if(l && r)
- {
- return *l != *r;
- }
- else
- {
- return l || r;
- }
-}
-
-template<typename T, typename U>
-inline bool operator<(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
-{
- T* l = lhs.get();
- U* r = rhs.get();
- if(l && r)
- {
- return *l < *r;
- }
- else
- {
- return !l && r;
- }
-}
-
-template<typename T>
-class Handle : public HandleBase<T>
-{
-public:
-
- Handle(T* p = 0)
- {
- _ptr = p;
-
- if(_ptr)
- {
- _ptr->__incRef();
- }
- }
-
- template<typename Y>
- Handle(const Handle<Y>& r)
- {
- _ptr = r._ptr;
-
- if(_ptr)
- {
- _ptr->__incRef();
- }
- }
-
-#ifdef _WIN32 // COMPILERBUG: Is VC++ or GNU C++ right here???
- template<>
- Handle(const Handle<T>& r)
-#else
- Handle(const Handle& r)
-#endif
- {
- _ptr = r._ptr;
-
- if(_ptr)
- {
- _ptr->__incRef();
- }
- }
-
- ~Handle()
- {
- if(_ptr)
- {
- _ptr->__decRef();
- }
- }
-
- Handle& operator=(T* p)
- {
- if(_ptr != p)
- {
- if(p)
- {
- p->__incRef();
- }
-
- if(_ptr)
- {
- _ptr->__decRef();
- }
-
- _ptr = p;
- }
- return *this;
- }
-
- template<typename Y>
- Handle& operator=(const Handle<Y>& r)
- {
- if(_ptr != r._ptr)
- {
- if(r._ptr)
- {
- r._ptr->__incRef();
- }
-
- if(_ptr)
- {
- _ptr->__decRef();
- }
-
- _ptr = r._ptr;
- }
- return *this;
- }
-
-#ifdef _WIN32 // COMPILERBUG: Is VC++ or GNU C++ right here???
- template<>
- Handle& operator=(const Handle<T>& r)
-#else
- Handle& operator=(const Handle& r)
-#endif
- {
- if(_ptr != r._ptr)
- {
- if(r._ptr)
- {
- r._ptr->__incRef();
- }
-
- if(_ptr)
- {
- _ptr->__decRef();
- }
-
- _ptr = r._ptr;
- }
- return *this;
- }
-
- template<class Y>
- static Handle dynamicCast(const HandleBase<Y>& r)
- {
- return Handle(dynamic_cast<T*>(r._ptr));
- }
-
- template<class Y>
- static Handle dynamicCast(Y* p)
- {
- return Handle(dynamic_cast<T*>(p));
- }
-};
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_HANDLE_H
+#define ICE_UTIL_HANDLE_H
+
+#include <IceUtil/Exception.h>
+#include <algorithm>
+
+//
+// "Handle" or "smart pointer" class for classes derived from
+// IceUtil::Shared or IceUtil::SimpleShared.
+//
+namespace IceUtil
+{
+
+template<typename T>
+class HandleBase
+{
+public:
+
+ typedef T element_type;
+
+ T* get() const
+ {
+ return _ptr;
+ }
+
+ T* operator->() const
+ {
+ if(!_ptr)
+ {
+ throw NullHandleException(__FILE__, __LINE__);
+ }
+
+ return _ptr;
+ }
+
+ operator bool() const
+ {
+ return _ptr ? true : false;
+ }
+
+ void swap(HandleBase& other)
+ {
+ std::swap(_ptr, other._ptr);
+ }
+
+ T* _ptr;
+};
+
+template<typename T, typename U>
+inline bool operator==(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
+{
+ T* l = lhs.get();
+ U* r = rhs.get();
+ if(l && r)
+ {
+ return *l == *r;
+ }
+ else
+ {
+ return !l && !r;
+ }
+}
+
+template<typename T, typename U>
+inline bool operator!=(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
+{
+ T* l = lhs.get();
+ U* r = rhs.get();
+ if(l && r)
+ {
+ return *l != *r;
+ }
+ else
+ {
+ return l || r;
+ }
+}
+
+template<typename T, typename U>
+inline bool operator<(const HandleBase<T>& lhs, const HandleBase<U>& rhs)
+{
+ T* l = lhs.get();
+ U* r = rhs.get();
+ if(l && r)
+ {
+ return *l < *r;
+ }
+ else
+ {
+ return !l && r;
+ }
+}
+
+template<typename T>
+class Handle : public HandleBase<T>
+{
+public:
+
+ Handle(T* p = 0)
+ {
+ _ptr = p;
+
+ if(_ptr)
+ {
+ _ptr->__incRef();
+ }
+ }
+
+ template<typename Y>
+ Handle(const Handle<Y>& r)
+ {
+ _ptr = r._ptr;
+
+ if(_ptr)
+ {
+ _ptr->__incRef();
+ }
+ }
+
+#ifdef _WIN32 // COMPILERBUG: Is VC++ or GNU C++ right here???
+ template<>
+ Handle(const Handle<T>& r)
+#else
+ Handle(const Handle& r)
+#endif
+ {
+ _ptr = r._ptr;
+
+ if(_ptr)
+ {
+ _ptr->__incRef();
+ }
+ }
+
+ ~Handle()
+ {
+ if(_ptr)
+ {
+ _ptr->__decRef();
+ }
+ }
+
+ Handle& operator=(T* p)
+ {
+ if(_ptr != p)
+ {
+ if(p)
+ {
+ p->__incRef();
+ }
+
+ if(_ptr)
+ {
+ _ptr->__decRef();
+ }
+
+ _ptr = p;
+ }
+ return *this;
+ }
+
+ template<typename Y>
+ Handle& operator=(const Handle<Y>& r)
+ {
+ if(_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ r._ptr->__incRef();
+ }
+
+ if(_ptr)
+ {
+ _ptr->__decRef();
+ }
+
+ _ptr = r._ptr;
+ }
+ return *this;
+ }
+
+#ifdef _WIN32 // COMPILERBUG: Is VC++ or GNU C++ right here???
+ template<>
+ Handle& operator=(const Handle<T>& r)
+#else
+ Handle& operator=(const Handle& r)
+#endif
+ {
+ if(_ptr != r._ptr)
+ {
+ if(r._ptr)
+ {
+ r._ptr->__incRef();
+ }
+
+ if(_ptr)
+ {
+ _ptr->__decRef();
+ }
+
+ _ptr = r._ptr;
+ }
+ return *this;
+ }
+
+ template<class Y>
+ static Handle dynamicCast(const HandleBase<Y>& r)
+ {
+ return Handle(dynamic_cast<T*>(r._ptr));
+ }
+
+ template<class Y>
+ static Handle dynamicCast(Y* p)
+ {
+ return Handle(dynamic_cast<T*>(p));
+ }
+};
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/IceUtil.h b/cpp/include/IceUtil/IceUtil.h
index 5821455d840..64497d6a393 100644
--- a/cpp/include/IceUtil/IceUtil.h
+++ b/cpp/include/IceUtil/IceUtil.h
@@ -1,32 +1,32 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_ICE_UTIL_H
-#define ICE_UTIL_ICE_UTIL_H
-
-//
-// This file must include *all* other headers of IceUtil.
-//
-
-#include <IceUtil/Functional.h>
-#include <IceUtil/Shared.h>
-#include <IceUtil/Unicode.h>
-#include <IceUtil/UUID.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/RecMutex.h>
-#include <IceUtil/RWRecMutex.h>
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Thread.h>
-#include <IceUtil/Base64.h>
-#include <IceUtil/Time.h>
-#include <IceUtil/InputUtil.h>
-#include <IceUtil/OutputUtil.h>
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_ICE_UTIL_H
+#define ICE_UTIL_ICE_UTIL_H
+
+//
+// This file must include *all* other headers of IceUtil.
+//
+
+#include <IceUtil/Functional.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Unicode.h>
+#include <IceUtil/UUID.h>
+#include <IceUtil/Mutex.h>
+#include <IceUtil/RecMutex.h>
+#include <IceUtil/RWRecMutex.h>
+#include <IceUtil/Monitor.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/Base64.h>
+#include <IceUtil/Time.h>
+#include <IceUtil/InputUtil.h>
+#include <IceUtil/OutputUtil.h>
+
+#endif
diff --git a/cpp/include/IceUtil/InputUtil.h b/cpp/include/IceUtil/InputUtil.h
index ed95e84bbfe..6de10f0d966 100644
--- a/cpp/include/IceUtil/InputUtil.h
+++ b/cpp/include/IceUtil/InputUtil.h
@@ -1,65 +1,65 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_INPUT_UTIL_H
-#define ICE_UTIL_INPUT_UTIL_H
-
-#include <IceUtil/Config.h>
-#include <string>
-#include <limits.h>
-
-namespace IceUtil
-{
-
-//
-// strToInt64() is drop-in replacement for UNIX strtoll()
-//
-ICE_UTIL_API Int64 strToInt64(const char*, char**, int);
-
-//
-// stringToInt64 converts a string into a signed 64-bit integer.
-//
-// bool stringToInt64(const std::string& stringToParse, Int64& result, std::string::size_type& pos);
-//
-// Semantics:
-//
-// - Ignore leading and trailing 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
-//
-// - if pos == string::npos, there are no trailing non-whitespace characters following the converted string
-//
-// - if pos != string::npos, there are trailing non-whitespace characters following the converted string;
-// pos indicates the first such character
-//
-// - return value == false indicates an unsuccessful conversion:
-//
-// - result == 0 indicates that no digits were available for conversion
-//
-// - result == INT64MIN or result == INT64MAX indicate underflow or overflow.
-//
-// - if pos == string::npos, the string did not contain trailing non-whitespace characters
-//
-// - if pos != string::npos, the string contained trailing non-whitespace characters following the
-// digits and pos indicates the first such character. (Note that all digits up to the first
-// non-digit, non-whitespace character are consumed, regardless of how far into the digit string
-// an overflow is detected.)
-//
-ICE_UTIL_API bool stringToInt64(const std::string&, Int64&, std::string::size_type&);
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_INPUT_UTIL_H
+#define ICE_UTIL_INPUT_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <string>
+#include <limits.h>
+
+namespace IceUtil
+{
+
+//
+// strToInt64() is drop-in replacement for UNIX strtoll()
+//
+ICE_UTIL_API Int64 strToInt64(const char*, char**, int);
+
+//
+// stringToInt64 converts a string into a signed 64-bit integer.
+//
+// bool stringToInt64(const std::string& stringToParse, Int64& result, std::string::size_type& pos);
+//
+// Semantics:
+//
+// - Ignore leading and trailing 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
+//
+// - if pos == string::npos, there are no trailing non-whitespace characters following the converted string
+//
+// - if pos != string::npos, there are trailing non-whitespace characters following the converted string;
+// pos indicates the first such character
+//
+// - return value == false indicates an unsuccessful conversion:
+//
+// - result == 0 indicates that no digits were available for conversion
+//
+// - result == INT64MIN or result == INT64MAX indicate underflow or overflow.
+//
+// - if pos == string::npos, the string did not contain trailing non-whitespace characters
+//
+// - if pos != string::npos, the string contained trailing non-whitespace characters following the
+// digits and pos indicates the first such character. (Note that all digits up to the first
+// non-digit, non-whitespace character are consumed, regardless of how far into the digit string
+// an overflow is detected.)
+//
+ICE_UTIL_API bool stringToInt64(const std::string&, Int64&, std::string::size_type&);
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Lock.h b/cpp/include/IceUtil/Lock.h
index 13f8d5fa2c7..c22d08d3f62 100644
--- a/cpp/include/IceUtil/Lock.h
+++ b/cpp/include/IceUtil/Lock.h
@@ -1,72 +1,72 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_LOCK_H
-#define ICE_UTIL_LOCK_H
-
-#include <IceUtil/Config.h>
-
-namespace IceUtil
-{
-
-//
-// Forward declarations.
-//
-class Cond;
-
-template <typename T>
-class Lock
-{
-public:
-
- Lock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.lock();
- }
-
- ~Lock()
- {
- _mutex.unlock();
- }
-
-private:
-
- const T& _mutex;
-
- friend class Cond;
-};
-
-template <typename T>
-class TryLock
-{
-public:
-
- TryLock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.trylock();
- }
-
- ~TryLock()
- {
- _mutex.unlock();
- }
-
-private:
-
- const T& _mutex;
-
- friend class Cond;
-};
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_LOCK_H
+#define ICE_UTIL_LOCK_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+//
+// Forward declarations.
+//
+class Cond;
+
+template <typename T>
+class Lock
+{
+public:
+
+ Lock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.lock();
+ }
+
+ ~Lock()
+ {
+ _mutex.unlock();
+ }
+
+private:
+
+ const T& _mutex;
+
+ friend class Cond;
+};
+
+template <typename T>
+class TryLock
+{
+public:
+
+ TryLock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.trylock();
+ }
+
+ ~TryLock()
+ {
+ _mutex.unlock();
+ }
+
+private:
+
+ const T& _mutex;
+
+ friend class Cond;
+};
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/Monitor.h b/cpp/include/IceUtil/Monitor.h
index 3fe6e76d943..429b595889b 100644
--- a/cpp/include/IceUtil/Monitor.h
+++ b/cpp/include/IceUtil/Monitor.h
@@ -1,235 +1,235 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#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 ICE_UTIL_API Monitor
-{
-public:
-
- typedef Lock<Monitor<T> > Lock;
- typedef TryLock<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;
- void 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
-{
- if(_mutex.lock())
- {
- //
- // On the first mutex acquisition reset the number pending
- // notifications.
- //
- _nnotify = 0;
- }
-}
-
-template <class T> inline void
-IceUtil::Monitor<T>::unlock() const
-{
- int nnotify = _nnotify;
- if(_mutex.unlock())
- {
- //
- // Perform any pending notifications.
- //
- notifyImpl(nnotify);
- }
-}
-
-template <class T> inline void
-IceUtil::Monitor<T>::trylock() const
-{
- if(_mutex.trylock())
- {
- //
- // On the first mutex acquisition reset the number pending
- // notifications.
- //
- _nnotify = 0;
- }
-}
-
-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
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#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 ICE_UTIL_API Monitor
+{
+public:
+
+ typedef Lock<Monitor<T> > Lock;
+ typedef TryLock<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;
+ void 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
+{
+ if(_mutex.lock())
+ {
+ //
+ // On the first mutex acquisition reset the number pending
+ // notifications.
+ //
+ _nnotify = 0;
+ }
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::unlock() const
+{
+ int nnotify = _nnotify;
+ if(_mutex.unlock())
+ {
+ //
+ // Perform any pending notifications.
+ //
+ notifyImpl(nnotify);
+ }
+}
+
+template <class T> inline void
+IceUtil::Monitor<T>::trylock() const
+{
+ if(_mutex.trylock())
+ {
+ //
+ // On the first mutex acquisition reset the number pending
+ // notifications.
+ //
+ _nnotify = 0;
+ }
+}
+
+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
diff --git a/cpp/include/IceUtil/Mutex.h b/cpp/include/IceUtil/Mutex.h
index e6ce737d4e3..44e8e682365 100644
--- a/cpp/include/IceUtil/Mutex.h
+++ b/cpp/include/IceUtil/Mutex.h
@@ -1,250 +1,250 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// 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>
-
-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_UTIL_API Mutex
-{
-public:
-
- //
- // Lock & TryLock typedefs.
- //
- typedef Lock<Mutex> Lock;
- typedef TryLock<Mutex> TryLock;
-
- Mutex();
- ~Mutex();
-
- //
- // Note that lock/trylock & unlock in general should not be used
- // directly. Instead use Lock & TryLock.
- //
-
- //
- // The boolean values are for the Monitor implementation which
- // needs 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).
- //
-
- //
- // Return true if the mutex has been locked for the first time.
- //
- bool lock() const;
-
- //
- // Throw ThreadLockedException in the case that the lock call would
- // block (that is the mutex is already owned by some other
- // thread). Returns true if the mutex has been locked for the
- // first time.
- //
- bool trylock() const;
-
- //
- // Returns true if the mutex has been unlocked for the last time
- // (false otherwise).
- //
- bool unlock() const;
-
-private:
-
- // 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
- {
- };
-#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.
-//
-
-#ifdef _WIN32
-
-inline
-Mutex::Mutex()
-{
- InitializeCriticalSection(&_mutex);
-}
-
-inline
-Mutex::~Mutex()
-{
- DeleteCriticalSection(&_mutex);
-}
-
-inline bool
-Mutex::lock() const
-{
- EnterCriticalSection(&_mutex);
- //
- // If necessary this can be removed and replaced with a _count
- // member (like the UNIX implementation of RecMutex).
- //
- assert(_mutex.RecursionCount == 1);
- return true;
-}
-
-inline bool
-Mutex::trylock() const
-{
- if(!TryEnterCriticalSection(&_mutex))
- {
- throw ThreadLockedException(__FILE__, __LINE__);
- }
- if(_mutex.RecursionCount > 1)
- {
- LeaveCriticalSection(&_mutex);
- throw ThreadLockedException(__FILE__, __LINE__);
- }
- return true;
-}
-
-inline bool
-Mutex::unlock() const
-{
- assert(_mutex.RecursionCount == 1);
- LeaveCriticalSection(&_mutex);
- return true;
-}
-
-inline void
-Mutex::unlock(LockState& state) const
-{
- LeaveCriticalSection(&_mutex);
-}
-
-inline void
-Mutex::lock(LockState&) const
-{
- EnterCriticalSection(&_mutex);
-}
-
-#else
-
-inline
-Mutex::Mutex()
-{
- int rc = pthread_mutex_init(&_mutex, 0);
- if(rc != 0)
- {
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
-}
-
-inline
-Mutex::~Mutex()
-{
- int rc = 0;
- rc = pthread_mutex_destroy(&_mutex);
- assert(rc == 0);
-}
-
-inline bool
-Mutex::lock() const
-{
- int rc = pthread_mutex_lock(&_mutex);
- if(rc != 0)
- {
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
- return true;
-}
-
-inline bool
-Mutex::trylock() const
-{
- int rc = pthread_mutex_trylock(&_mutex);
- if(rc != 0)
- {
- if(rc == EBUSY)
- {
- throw ThreadLockedException(__FILE__, __LINE__);
- }
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
- return true;
-}
-
-inline bool
-Mutex::unlock() const
-{
- int rc = pthread_mutex_unlock(&_mutex);
- if(rc != 0)
- {
- throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
- }
- return true;
-}
-
-inline void
-Mutex::unlock(LockState& state) const
-{
- state.mutex = &_mutex;
-}
-
-inline void
-Mutex::lock(LockState&) const
-{
-}
-
-#endif
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// 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>
+
+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_UTIL_API Mutex
+{
+public:
+
+ //
+ // Lock & TryLock typedefs.
+ //
+ typedef Lock<Mutex> Lock;
+ typedef TryLock<Mutex> TryLock;
+
+ Mutex();
+ ~Mutex();
+
+ //
+ // Note that lock/trylock & unlock in general should not be used
+ // directly. Instead use Lock & TryLock.
+ //
+
+ //
+ // The boolean values are for the Monitor implementation which
+ // needs 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).
+ //
+
+ //
+ // Return true if the mutex has been locked for the first time.
+ //
+ bool lock() const;
+
+ //
+ // Throw ThreadLockedException in the case that the lock call would
+ // block (that is the mutex is already owned by some other
+ // thread). Returns true if the mutex has been locked for the
+ // first time.
+ //
+ bool trylock() const;
+
+ //
+ // Returns true if the mutex has been unlocked for the last time
+ // (false otherwise).
+ //
+ bool unlock() const;
+
+private:
+
+ // 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
+ {
+ };
+#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.
+//
+
+#ifdef _WIN32
+
+inline
+Mutex::Mutex()
+{
+ InitializeCriticalSection(&_mutex);
+}
+
+inline
+Mutex::~Mutex()
+{
+ DeleteCriticalSection(&_mutex);
+}
+
+inline bool
+Mutex::lock() const
+{
+ EnterCriticalSection(&_mutex);
+ //
+ // If necessary this can be removed and replaced with a _count
+ // member (like the UNIX implementation of RecMutex).
+ //
+ assert(_mutex.RecursionCount == 1);
+ return true;
+}
+
+inline bool
+Mutex::trylock() const
+{
+ if(!TryEnterCriticalSection(&_mutex))
+ {
+ throw ThreadLockedException(__FILE__, __LINE__);
+ }
+ if(_mutex.RecursionCount > 1)
+ {
+ LeaveCriticalSection(&_mutex);
+ throw ThreadLockedException(__FILE__, __LINE__);
+ }
+ return true;
+}
+
+inline bool
+Mutex::unlock() const
+{
+ assert(_mutex.RecursionCount == 1);
+ LeaveCriticalSection(&_mutex);
+ return true;
+}
+
+inline void
+Mutex::unlock(LockState& state) const
+{
+ LeaveCriticalSection(&_mutex);
+}
+
+inline void
+Mutex::lock(LockState&) const
+{
+ EnterCriticalSection(&_mutex);
+}
+
+#else
+
+inline
+Mutex::Mutex()
+{
+ int rc = pthread_mutex_init(&_mutex, 0);
+ if(rc != 0)
+ {
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+}
+
+inline
+Mutex::~Mutex()
+{
+ int rc = 0;
+ rc = pthread_mutex_destroy(&_mutex);
+ assert(rc == 0);
+}
+
+inline bool
+Mutex::lock() const
+{
+ int rc = pthread_mutex_lock(&_mutex);
+ if(rc != 0)
+ {
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+ return true;
+}
+
+inline bool
+Mutex::trylock() const
+{
+ int rc = pthread_mutex_trylock(&_mutex);
+ if(rc != 0)
+ {
+ if(rc == EBUSY)
+ {
+ throw ThreadLockedException(__FILE__, __LINE__);
+ }
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+ return true;
+}
+
+inline bool
+Mutex::unlock() const
+{
+ int rc = pthread_mutex_unlock(&_mutex);
+ if(rc != 0)
+ {
+ throw ThreadSyscallException(strerror(rc), __FILE__, __LINE__);
+ }
+ return true;
+}
+
+inline void
+Mutex::unlock(LockState& state) const
+{
+ state.mutex = &_mutex;
+}
+
+inline void
+Mutex::lock(LockState&) const
+{
+}
+
+#endif
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/OutputUtil.h b/cpp/include/IceUtil/OutputUtil.h
index 8b2ed0996bd..4b0e321b64b 100644
--- a/cpp/include/IceUtil/OutputUtil.h
+++ b/cpp/include/IceUtil/OutputUtil.h
@@ -1,325 +1,325 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_OUTPUT_UTIL_H
-#define ICE_UTIL_OUTPUT_UTIL_H
-
-#include <IceUtil/Config.h>
-#include <fstream>
-#include <stack>
-
-namespace IceUtil
-{
-
-// ----------------------------------------------------------------------
-// OutputBase
-// ----------------------------------------------------------------------
-
-//
-// Technically it's not necessary to have print() & nl() as virtual
-// since the opeator<< functions are specific to each OutputBase
-// derivative. However, since it's possible to call print() & nl()
-// manually I've decided to leave them as virtual.
-//
-
-class ICE_UTIL_API OutputBase : public ::IceUtil::noncopyable
-{
-public:
-
- OutputBase();
- OutputBase(std::ostream&);
- OutputBase(const char*);
- virtual ~OutputBase();
-
- void setIndent(int); // What is the indent level?
- void setUseTab(bool); // Should we output tabs?
-
- void open(const char*); // Open output stream.
-
- virtual void print(const char*); // Print a string.
-
- void inc(); // Increment indentation level.
- void dec(); // Decrement indentation level.
-
- void useCurrentPosAsIndent(); // Save the current position as indentation.
- void zeroIndent(); // Use zero identation.
- void restoreIndent(); // Restore indentation.
-
- virtual void nl(); // Print newline.
- void sp(); // Print separator.
-
- bool operator!() const; // Check whether the output state is ok.
-
- std::streamsize width() const;
- std::streamsize width(std::streamsize newWidth);
-
- std::ios_base::fmtflags flags() const;
- std::ios_base::fmtflags flags(std::ios_base::fmtflags newFlags);
-
- std::ostream::char_type fill() const;
- std::ostream::char_type fill(std::ostream::char_type newFill);
-
-protected:
-
- std::ofstream _fout;
- std::ostream& _out;
- int _pos;
- int _indent;
- int _indentSize;
- std::stack<int> _indentSave;
- bool _useTab;
- bool _separator;
-};
-
-class ICE_UTIL_API NextLine
-{
-};
-extern ICE_UTIL_API NextLine nl;
-
-class ICE_UTIL_API Separator
-{
-};
-extern ICE_UTIL_API Separator sp;
-
-// ----------------------------------------------------------------------
-// Output
-// ----------------------------------------------------------------------
-
-class ICE_UTIL_API Output : public OutputBase
-{
-public:
-
- Output();
- Output(std::ostream&);
- Output(const char*);
-
- void setBeginBlock(const char *); // what do we use at block starts?
- void setEndBlock(const char *); // what do we use the block end?
-
- void sb(); // Start a block.
- void eb(); // End a block.
-
-private:
-
- std::string _blockStart;
- std::string _blockEnd;
-};
-
-template<typename T>
-Output&
-operator<<(Output& out, const T& val)
-{
- std::ostringstream s;
- s << val;
- out.print(s.str().c_str());
- return out;
-}
-
-template<>
-inline Output&
-operator<<(Output& o, const NextLine&)
-{
- o.nl();
- return o;
-}
-
-template<>
-inline Output&
-operator<<(Output& o, const Separator&)
-{
- o.sp();
- return o;
-}
-
-class ICE_UTIL_API StartBlock
-{
-};
-extern ICE_UTIL_API StartBlock sb;
-
-template<>
-inline Output&
-operator<<(Output& o, const StartBlock&)
-{
- o.sb();
- return o;
-}
-
-class ICE_UTIL_API EndBlock
-{
-};
-extern ICE_UTIL_API EndBlock eb;
-
-template<>
-inline Output&
-operator<<(Output& o, const EndBlock&)
-{
- o.eb();
- return o;
-}
-
-ICE_UTIL_API Output& operator<<(Output&, std::ios_base& (*)(std::ios_base&));
-
-// ----------------------------------------------------------------------
-// XMLOutput
-// ----------------------------------------------------------------------
-
-class ICE_UTIL_API XMLOutput : public OutputBase
-{
-public:
-
- XMLOutput();
- XMLOutput(std::ostream&);
- XMLOutput(const char*);
-
- void setSGML(bool);
- virtual void print(const char*); // Print a string.
-
- virtual void nl(); // Print newline.
-
- void se(const std::string&); // Start an element.
- void ee(); // End an element.
- void attr(const std::string&, const std::string&); // Add an attribute to an element.
-
- void startEscapes();
- void endEscapes();
-
- std::string currentElement() const;
-
-private:
-
- ::std::string escape(const ::std::string&) const;
-
- std::stack<std::string> _elementStack;
-
- bool _se;
- bool _text;
-
- bool _sgml;
- bool _escape;
-};
-
-template<typename T>
-XMLOutput&
-operator<<(XMLOutput& out, const T& val)
-{
- std::ostringstream s;
- s << val;
- out.print(s.str().c_str());
- return out;
-}
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const NextLine&)
-{
- o.nl();
- return o;
-}
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const Separator&)
-{
- o.sp();
- return o;
-}
-
-class ICE_UTIL_API EndElement
-{
-};
-extern ICE_UTIL_API EndElement ee;
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const EndElement&)
-{
- o.ee();
- return o;
-}
-
-class ICE_UTIL_API StartElement
-{
-public:
-
- StartElement(const std::string&);
-
- const std::string& getName() const;
-
-private:
-
- const std::string _name;
-};
-
-typedef StartElement se;
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const StartElement& e)
-{
- o.se(e.getName());
- return o;
-}
-
-class ICE_UTIL_API Attribute
-{
-public:
-
- Attribute(const ::std::string&, const ::std::string&);
-
- const ::std::string& getName() const;
- const ::std::string& getValue() const;
-
-private:
-
- const ::std::string _name;
- const ::std::string _value;
-};
-
-typedef Attribute attr;
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const Attribute& e)
-{
- o.attr(e.getName(), e.getValue());
- return o;
-}
-
-class ICE_UTIL_API StartEscapes
-{
-};
-extern ICE_UTIL_API StartEscapes startEscapes;
-
-class ICE_UTIL_API EndEscapes
-{
-};
-extern ICE_UTIL_API EndEscapes endEscapes;
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const StartEscapes&)
-{
- o.startEscapes();
- return o;
-}
-
-template<>
-inline XMLOutput&
-operator<<(XMLOutput& o, const EndEscapes&)
-{
- o.endEscapes();
- return o;
-}
-
-ICE_UTIL_API XMLOutput& operator<<(XMLOutput&, std::ios_base& (*)(std::ios_base&));
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_OUTPUT_UTIL_H
+#define ICE_UTIL_OUTPUT_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <fstream>
+#include <stack>
+
+namespace IceUtil
+{
+
+// ----------------------------------------------------------------------
+// OutputBase
+// ----------------------------------------------------------------------
+
+//
+// Technically it's not necessary to have print() & nl() as virtual
+// since the opeator<< functions are specific to each OutputBase
+// derivative. However, since it's possible to call print() & nl()
+// manually I've decided to leave them as virtual.
+//
+
+class ICE_UTIL_API OutputBase : public ::IceUtil::noncopyable
+{
+public:
+
+ OutputBase();
+ OutputBase(std::ostream&);
+ OutputBase(const char*);
+ virtual ~OutputBase();
+
+ void setIndent(int); // What is the indent level?
+ void setUseTab(bool); // Should we output tabs?
+
+ void open(const char*); // Open output stream.
+
+ virtual void print(const char*); // Print a string.
+
+ void inc(); // Increment indentation level.
+ void dec(); // Decrement indentation level.
+
+ void useCurrentPosAsIndent(); // Save the current position as indentation.
+ void zeroIndent(); // Use zero identation.
+ void restoreIndent(); // Restore indentation.
+
+ virtual void nl(); // Print newline.
+ void sp(); // Print separator.
+
+ bool operator!() const; // Check whether the output state is ok.
+
+ std::streamsize width() const;
+ std::streamsize width(std::streamsize newWidth);
+
+ std::ios_base::fmtflags flags() const;
+ std::ios_base::fmtflags flags(std::ios_base::fmtflags newFlags);
+
+ std::ostream::char_type fill() const;
+ std::ostream::char_type fill(std::ostream::char_type newFill);
+
+protected:
+
+ std::ofstream _fout;
+ std::ostream& _out;
+ int _pos;
+ int _indent;
+ int _indentSize;
+ std::stack<int> _indentSave;
+ bool _useTab;
+ bool _separator;
+};
+
+class ICE_UTIL_API NextLine
+{
+};
+extern ICE_UTIL_API NextLine nl;
+
+class ICE_UTIL_API Separator
+{
+};
+extern ICE_UTIL_API Separator sp;
+
+// ----------------------------------------------------------------------
+// Output
+// ----------------------------------------------------------------------
+
+class ICE_UTIL_API Output : public OutputBase
+{
+public:
+
+ Output();
+ Output(std::ostream&);
+ Output(const char*);
+
+ void setBeginBlock(const char *); // what do we use at block starts?
+ void setEndBlock(const char *); // what do we use the block end?
+
+ void sb(); // Start a block.
+ void eb(); // End a block.
+
+private:
+
+ std::string _blockStart;
+ std::string _blockEnd;
+};
+
+template<typename T>
+Output&
+operator<<(Output& out, const T& val)
+{
+ std::ostringstream s;
+ s << val;
+ out.print(s.str().c_str());
+ return out;
+}
+
+template<>
+inline Output&
+operator<<(Output& o, const NextLine&)
+{
+ o.nl();
+ return o;
+}
+
+template<>
+inline Output&
+operator<<(Output& o, const Separator&)
+{
+ o.sp();
+ return o;
+}
+
+class ICE_UTIL_API StartBlock
+{
+};
+extern ICE_UTIL_API StartBlock sb;
+
+template<>
+inline Output&
+operator<<(Output& o, const StartBlock&)
+{
+ o.sb();
+ return o;
+}
+
+class ICE_UTIL_API EndBlock
+{
+};
+extern ICE_UTIL_API EndBlock eb;
+
+template<>
+inline Output&
+operator<<(Output& o, const EndBlock&)
+{
+ o.eb();
+ return o;
+}
+
+ICE_UTIL_API Output& operator<<(Output&, std::ios_base& (*)(std::ios_base&));
+
+// ----------------------------------------------------------------------
+// XMLOutput
+// ----------------------------------------------------------------------
+
+class ICE_UTIL_API XMLOutput : public OutputBase
+{
+public:
+
+ XMLOutput();
+ XMLOutput(std::ostream&);
+ XMLOutput(const char*);
+
+ void setSGML(bool);
+ virtual void print(const char*); // Print a string.
+
+ virtual void nl(); // Print newline.
+
+ void se(const std::string&); // Start an element.
+ void ee(); // End an element.
+ void attr(const std::string&, const std::string&); // Add an attribute to an element.
+
+ void startEscapes();
+ void endEscapes();
+
+ std::string currentElement() const;
+
+private:
+
+ ::std::string escape(const ::std::string&) const;
+
+ std::stack<std::string> _elementStack;
+
+ bool _se;
+ bool _text;
+
+ bool _sgml;
+ bool _escape;
+};
+
+template<typename T>
+XMLOutput&
+operator<<(XMLOutput& out, const T& val)
+{
+ std::ostringstream s;
+ s << val;
+ out.print(s.str().c_str());
+ return out;
+}
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const NextLine&)
+{
+ o.nl();
+ return o;
+}
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const Separator&)
+{
+ o.sp();
+ return o;
+}
+
+class ICE_UTIL_API EndElement
+{
+};
+extern ICE_UTIL_API EndElement ee;
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const EndElement&)
+{
+ o.ee();
+ return o;
+}
+
+class ICE_UTIL_API StartElement
+{
+public:
+
+ StartElement(const std::string&);
+
+ const std::string& getName() const;
+
+private:
+
+ const std::string _name;
+};
+
+typedef StartElement se;
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const StartElement& e)
+{
+ o.se(e.getName());
+ return o;
+}
+
+class ICE_UTIL_API Attribute
+{
+public:
+
+ Attribute(const ::std::string&, const ::std::string&);
+
+ const ::std::string& getName() const;
+ const ::std::string& getValue() const;
+
+private:
+
+ const ::std::string _name;
+ const ::std::string _value;
+};
+
+typedef Attribute attr;
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const Attribute& e)
+{
+ o.attr(e.getName(), e.getValue());
+ return o;
+}
+
+class ICE_UTIL_API StartEscapes
+{
+};
+extern ICE_UTIL_API StartEscapes startEscapes;
+
+class ICE_UTIL_API EndEscapes
+{
+};
+extern ICE_UTIL_API EndEscapes endEscapes;
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const StartEscapes&)
+{
+ o.startEscapes();
+ return o;
+}
+
+template<>
+inline XMLOutput&
+operator<<(XMLOutput& o, const EndEscapes&)
+{
+ o.endEscapes();
+ return o;
+}
+
+ICE_UTIL_API XMLOutput& operator<<(XMLOutput&, std::ios_base& (*)(std::ios_base&));
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/RWRecMutex.h b/cpp/include/IceUtil/RWRecMutex.h
index cc09ab4113e..23eba24b62d 100644
--- a/cpp/include/IceUtil/RWRecMutex.h
+++ b/cpp/include/IceUtil/RWRecMutex.h
@@ -1,256 +1,256 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_RW_REC_MUTEX_H
-#define ICE_UTIL_RW_REC_MUTEX_H
-
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Cond.h>
-#include <IceUtil/Thread.h>
-
-namespace IceUtil
-{
-
-template <typename T>
-class RLock
-{
-public:
-
- RLock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.readlock();
- }
-
- ~RLock()
- {
- _mutex.unlock();
- }
-
- void
- upgrade()
- {
- _mutex.upgrade();
- }
-
- void
- timedUpgrade(const Time& timeout)
- {
- _mutex.timedUpgrade(timeout);
- }
-
-private:
-
- const T& _mutex;
-};
-
-template <typename T>
-class TryRLock
-{
-public:
-
- TryRLock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.tryReadlock();
- }
-
- TryRLock(const T& mutex, const Time& timeout) :
- _mutex(mutex)
- {
- _mutex.timedTryReadlock(timeout);
- }
-
- ~TryRLock()
- {
- _mutex.unlock();
- }
-
- void
- upgrade()
- {
- _mutex.upgrade();
- }
-
- void
- timedUpgrade(const Time& timeout)
- {
- _mutex.timedUpgrade(timeout);
- }
-
-private:
-
- const T& _mutex;
-};
-
-template <typename T>
-class WLock
-{
-public:
-
- WLock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.writelock();
- }
-
- ~WLock()
- {
- _mutex.unlock();
- }
-
-private:
-
- const T& _mutex;
-};
-
-template <typename T>
-class TryWLock
-{
-public:
-
- TryWLock(const T& mutex) :
- _mutex(mutex)
- {
- _mutex.tryWritelock();
- }
-
- TryWLock(const T& mutex, const Time& timeout) :
- _mutex(mutex)
- {
- _mutex.timedTryWritelock(timeout);
- }
-
- ~TryWLock()
- {
- _mutex.unlock();
- }
-
-private:
-
- const T& _mutex;
-};
-
-//
-// Concurrency primitive that allows many readers & one writer access
-// to a data structure. Writers have priority over readers. The
-// structure is not strictly fair in that there is no absolute queue
-// of waiting writers - that is managed by a condition variable.
-//
-// Both Reader & Writer mutexes can be recursively locked. Calling
-// WLock (or TryWLock) while holding a read lock promotes the reader
-// to a writer lock.
-//
-class ICE_UTIL_API RWRecMutex
-{
-public:
-
- //
- // RLock (reader) & WLock (writer) typedefs.
- //
- typedef RLock<RWRecMutex> RLock;
- typedef TryRLock<RWRecMutex> TryRLock;
- typedef WLock<RWRecMutex> WLock;
- typedef TryWLock<RWRecMutex> TryWLock;
-
- RWRecMutex();
- ~RWRecMutex();
-
- //
- // Note that readlock/writelock & unlock in general should not be
- // used directly. Instead use RLock & WLock.
- //
-
- //
- // Acquire a read lock.
- //
- void readlock() const;
-
- //
- // Try to acquire a read lock.
- //
- void tryReadlock() const;
-
- //
- // Try to acquire a read lock for upto the given timeout.
- //
- void timedTryReadlock(const Time&) const;
-
- //
- // Acquire a write lock.
- //
- void writelock() const;
-
- //
- // Acquire a write lock.
- //
- void tryWritelock() const;
-
- //
- // Acquire a write lock for up to the given timeout.
- //
- void timedTryWritelock(const Time&) const;
-
- //
- // Unlock the reader/writer lock.
- //
- void unlock() const;
-
- //
- // Upgrade the read lock to a writer lock. Note that this method
- // can only be called if the reader lock is not held recursively.
- //
- void upgrade() const;
-
- //
- // Upgrade the read lock to a writer lock for up to the given
- // timeout Note that this method can only be called if the reader
- // lock is not held recursively.
- //
- void timedUpgrade(const Time&) const;
-
-private:
-
- // noncopyable
- RWRecMutex(const RWRecMutex&);
- void operator=(const RWRecMutex&);
-
- //
- // Number of readers holding the lock. A positive number indicates
- // readers are active. A negative number means that a writer is
- // active.
- //
- mutable int _count;
-
- //
- // If there is an active writer this is a control for thread.
- //
- mutable ThreadControl _writerControl;
-
- //
- // Number of waiting writers.
- //
- mutable unsigned int _waitingWriters;
-
- //
- // Internal mutex.
- //
- Mutex _mutex;
-
- //
- // Two condition variables for waiting readers & writers.
- //
- mutable Cond _readers;
- mutable Cond _writers;
-};
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_RW_REC_MUTEX_H
+#define ICE_UTIL_RW_REC_MUTEX_H
+
+#include <IceUtil/Mutex.h>
+#include <IceUtil/Cond.h>
+#include <IceUtil/Thread.h>
+
+namespace IceUtil
+{
+
+template <typename T>
+class RLock
+{
+public:
+
+ RLock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.readlock();
+ }
+
+ ~RLock()
+ {
+ _mutex.unlock();
+ }
+
+ void
+ upgrade()
+ {
+ _mutex.upgrade();
+ }
+
+ void
+ timedUpgrade(const Time& timeout)
+ {
+ _mutex.timedUpgrade(timeout);
+ }
+
+private:
+
+ const T& _mutex;
+};
+
+template <typename T>
+class TryRLock
+{
+public:
+
+ TryRLock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.tryReadlock();
+ }
+
+ TryRLock(const T& mutex, const Time& timeout) :
+ _mutex(mutex)
+ {
+ _mutex.timedTryReadlock(timeout);
+ }
+
+ ~TryRLock()
+ {
+ _mutex.unlock();
+ }
+
+ void
+ upgrade()
+ {
+ _mutex.upgrade();
+ }
+
+ void
+ timedUpgrade(const Time& timeout)
+ {
+ _mutex.timedUpgrade(timeout);
+ }
+
+private:
+
+ const T& _mutex;
+};
+
+template <typename T>
+class WLock
+{
+public:
+
+ WLock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.writelock();
+ }
+
+ ~WLock()
+ {
+ _mutex.unlock();
+ }
+
+private:
+
+ const T& _mutex;
+};
+
+template <typename T>
+class TryWLock
+{
+public:
+
+ TryWLock(const T& mutex) :
+ _mutex(mutex)
+ {
+ _mutex.tryWritelock();
+ }
+
+ TryWLock(const T& mutex, const Time& timeout) :
+ _mutex(mutex)
+ {
+ _mutex.timedTryWritelock(timeout);
+ }
+
+ ~TryWLock()
+ {
+ _mutex.unlock();
+ }
+
+private:
+
+ const T& _mutex;
+};
+
+//
+// Concurrency primitive that allows many readers & one writer access
+// to a data structure. Writers have priority over readers. The
+// structure is not strictly fair in that there is no absolute queue
+// of waiting writers - that is managed by a condition variable.
+//
+// Both Reader & Writer mutexes can be recursively locked. Calling
+// WLock (or TryWLock) while holding a read lock promotes the reader
+// to a writer lock.
+//
+class ICE_UTIL_API RWRecMutex
+{
+public:
+
+ //
+ // RLock (reader) & WLock (writer) typedefs.
+ //
+ typedef RLock<RWRecMutex> RLock;
+ typedef TryRLock<RWRecMutex> TryRLock;
+ typedef WLock<RWRecMutex> WLock;
+ typedef TryWLock<RWRecMutex> TryWLock;
+
+ RWRecMutex();
+ ~RWRecMutex();
+
+ //
+ // Note that readlock/writelock & unlock in general should not be
+ // used directly. Instead use RLock & WLock.
+ //
+
+ //
+ // Acquire a read lock.
+ //
+ void readlock() const;
+
+ //
+ // Try to acquire a read lock.
+ //
+ void tryReadlock() const;
+
+ //
+ // Try to acquire a read lock for upto the given timeout.
+ //
+ void timedTryReadlock(const Time&) const;
+
+ //
+ // Acquire a write lock.
+ //
+ void writelock() const;
+
+ //
+ // Acquire a write lock.
+ //
+ void tryWritelock() const;
+
+ //
+ // Acquire a write lock for up to the given timeout.
+ //
+ void timedTryWritelock(const Time&) const;
+
+ //
+ // Unlock the reader/writer lock.
+ //
+ void unlock() const;
+
+ //
+ // Upgrade the read lock to a writer lock. Note that this method
+ // can only be called if the reader lock is not held recursively.
+ //
+ void upgrade() const;
+
+ //
+ // Upgrade the read lock to a writer lock for up to the given
+ // timeout Note that this method can only be called if the reader
+ // lock is not held recursively.
+ //
+ void timedUpgrade(const Time&) const;
+
+private:
+
+ // noncopyable
+ RWRecMutex(const RWRecMutex&);
+ void operator=(const RWRecMutex&);
+
+ //
+ // Number of readers holding the lock. A positive number indicates
+ // readers are active. A negative number means that a writer is
+ // active.
+ //
+ mutable int _count;
+
+ //
+ // If there is an active writer this is a control for thread.
+ //
+ mutable ThreadControl _writerControl;
+
+ //
+ // Number of waiting writers.
+ //
+ mutable unsigned int _waitingWriters;
+
+ //
+ // Internal mutex.
+ //
+ Mutex _mutex;
+
+ //
+ // Two condition variables for waiting readers & writers.
+ //
+ mutable Cond _readers;
+ mutable Cond _writers;
+};
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/RecMutex.h b/cpp/include/IceUtil/RecMutex.h
index 8aab8c48a21..eec4dca2796 100644
--- a/cpp/include/IceUtil/RecMutex.h
+++ b/cpp/include/IceUtil/RecMutex.h
@@ -1,112 +1,112 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_RMUTEX_H
-#define ICE_UTIL_RMUTEX_H
-
-#include <IceUtil/Config.h>
-#include <IceUtil/Lock.h>
-#include <IceUtil/ThreadException.h>
-
-namespace IceUtil
-{
-
-//
-// Forward declarations for friend.
-//
-class Cond;
-
-//
-// Recursive Mutex implementation.
-//
-class ICE_UTIL_API RecMutex
-{
-public:
-
- //
- // Lock & TryLock typedefs.
- //
- typedef Lock<RecMutex> Lock;
- typedef TryLock<RecMutex> TryLock;
-
- RecMutex();
- ~RecMutex();
-
- //
- // Note that lock/trylock & unlock in general should not be used
- // directly. Instead use Lock & TryLock.
- //
-
- //
- // The boolean values are for the Monitor implementation which
- // needs 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).
- //
-
- //
- // Return true if the mutex has been locked for the first time.
- //
- bool lock() const;
-
- //
- // Throw ThreadLockedException in the case that the lock call would
- // block (that is the mutex is already owned by some other
- // thread). Returns true if the mutex has been locked for the
- // first time.
- //
- bool trylock() const;
-
- //
- // Returns true if the mutex has been unlocked for the last time
- // (false otherwise).
- //
- bool unlock() const;
-
-private:
-
- // noncopyable
- RecMutex(const RecMutex&);
- void operator=(const RecMutex&);
-
- //
- // LockState and the lock/unlock variations are for use by the
- // Condition variable implementation.
- //
-#ifdef _WIN32
- struct LockState
- {
- int count;
- };
-#else
- struct LockState
- {
- pthread_mutex_t* mutex;
- int count;
- };
-#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
-
- mutable int _count;
-};
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_RMUTEX_H
+#define ICE_UTIL_RMUTEX_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Lock.h>
+#include <IceUtil/ThreadException.h>
+
+namespace IceUtil
+{
+
+//
+// Forward declarations for friend.
+//
+class Cond;
+
+//
+// Recursive Mutex implementation.
+//
+class ICE_UTIL_API RecMutex
+{
+public:
+
+ //
+ // Lock & TryLock typedefs.
+ //
+ typedef Lock<RecMutex> Lock;
+ typedef TryLock<RecMutex> TryLock;
+
+ RecMutex();
+ ~RecMutex();
+
+ //
+ // Note that lock/trylock & unlock in general should not be used
+ // directly. Instead use Lock & TryLock.
+ //
+
+ //
+ // The boolean values are for the Monitor implementation which
+ // needs 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).
+ //
+
+ //
+ // Return true if the mutex has been locked for the first time.
+ //
+ bool lock() const;
+
+ //
+ // Throw ThreadLockedException in the case that the lock call would
+ // block (that is the mutex is already owned by some other
+ // thread). Returns true if the mutex has been locked for the
+ // first time.
+ //
+ bool trylock() const;
+
+ //
+ // Returns true if the mutex has been unlocked for the last time
+ // (false otherwise).
+ //
+ bool unlock() const;
+
+private:
+
+ // noncopyable
+ RecMutex(const RecMutex&);
+ void operator=(const RecMutex&);
+
+ //
+ // LockState and the lock/unlock variations are for use by the
+ // Condition variable implementation.
+ //
+#ifdef _WIN32
+ struct LockState
+ {
+ int count;
+ };
+#else
+ struct LockState
+ {
+ pthread_mutex_t* mutex;
+ int count;
+ };
+#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
+
+ mutable int _count;
+};
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/Shared.h b/cpp/include/IceUtil/Shared.h
index 38c72dd343b..b9cc3c3d265 100644
--- a/cpp/include/IceUtil/Shared.h
+++ b/cpp/include/IceUtil/Shared.h
@@ -1,364 +1,364 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_SHARED_H
-#define ICE_UTIL_SHARED_H
-
-#include <IceUtil/Config.h>
-
-//
-// The inline assembler causes problems with shared libraries.
-//
-#if defined(__ICC) && !defined(_WIN32)
-# define ICE_USE_MUTEX_SHARED
-#endif
-
-#ifdef ICE_USE_MUTEX_SHARED
-# include <IceUtil/Mutex.h>
-#endif
-
-#if !defined(_WIN32) && !defined(ICE_USE_MUTEX_SHARED)
-
-//
-// Linux only. Unfortunately, asm/atomic.h builds non-SMP safe code
-// with non-SMP kernels. This means that executables compiled with a
-// non-SMP kernel would fail randomly due to concurrency errors with
-// reference counting on SMP hosts. Therefore the relevent pieces of
-// atomic.h are more-or-less duplicated.
-//
-
-/*
- * Make sure gcc doesn't try to be clever and move things around
- * on us. We need to use _exactly_ the address the user gave us,
- * not some alias that contains the same information.
- */
-struct ice_atomic_t
-{
- volatile int counter;
-};
-
-/*
- * ice_atomic_set - set ice_atomic variable
- * @v: pointer of type ice_atomic_t
- * @i: required value
- *
- * Atomically sets the value of @v to @i. Note that the guaranteed
- * useful range of an ice_atomic_t is only 24 bits.
- */
-inline void ice_atomic_set(ice_atomic_t* v, int i)
-{
- v->counter = i;
-}
-
-/*
- * ice_atomic_inc - increment ice_atomic variable
- * @v: pointer of type ice_atomic_t
- *
- * Atomically increments @v by 1. Note that the guaranteed useful
- * range of an ice_atomic_t is only 24 bits.
- *
- * Inlined because this operation is performance critical.
- */
-inline void ice_atomic_inc(ice_atomic_t *v)
-{
- __asm__ __volatile__(
- "lock ; incl %0"
- :"=m" (v->counter)
- :"m" (v->counter));
-}
-
-/**
- * ice_atomic_dec_and_test - decrement and test
- * @v: pointer of type ice_atomic_t
- *
- * Atomically decrements @v by 1 and returns true if the result is 0,
- * or false for all other cases. Note that the guaranteed useful
- * range of an ice_atomic_t is only 24 bits.
- *
- * Inlined because this operation is performance critical.
- */
-inline int ice_atomic_dec_and_test(ice_atomic_t *v)
-{
- unsigned char c;
- __asm__ __volatile__(
- "lock ; decl %0; sete %1"
- :"=m" (v->counter), "=qm" (c)
- :"m" (v->counter) : "memory");
- return c != 0;
-}
-
-/**
- * ice_atomic_exchange_add - same as InterlockedExchangeAdd. This
- * didn't come from atomic.h (the code was derived from similar code
- * in /usr/include/asm/rwsem.h)
- *
- * Inlined because this operation is performance critical.
- */
-inline int ice_atomic_exchange_add(int i, ice_atomic_t* v)
-{
- int tmp = i;
- __asm__ __volatile__(
- "lock ; xadd %0,(%2)"
- :"+r"(tmp), "=m"(v->counter)
- :"r"(v), "m"(v->counter)
- : "memory");
- return tmp + i;
-}
-
-#endif
-
-//
-// Base classes for reference counted types. The IceUtil::Handle
-// template can be used for smart pointers to types derived from these
-// bases.
-//
-// IceUtil::SimpleShared
-// =====================
-//
-// A non thread-safe base class for reference-counted types.
-//
-// IceUtil::Shared
-// ===============
-//
-// A thread-safe base class for reference-counted types.
-//
-namespace IceUtil
-{
-
-//
-// TODO: Not all operations in this class are performance critical,
-// thus not all of them should be inlined.
-//
-
-class SimpleShared : public noncopyable
-{
-public:
-
- SimpleShared() :
- _ref(0),
- _noDelete(false)
- {
- }
-
- virtual ~SimpleShared()
- {
- }
-
- void __incRef()
- {
- assert(_ref >= 0);
- ++_ref;
- }
-
- void __decRef()
- {
- assert(_ref > 0);
- if(--_ref == 0)
- {
- if(!_noDelete)
- {
- delete this;
- }
- }
- }
-
- int __getRef() const
- {
- return _ref;
- }
-
- void __setNoDelete(bool b)
- {
- _noDelete = b;
- }
-
-private:
-
- int _ref;
- bool _noDelete;
-};
-
-class Shared : public noncopyable
-{
-public:
-
- Shared();
- virtual ~Shared();
- void __incRef();
- void __decRef();
- int __getRef() const;
- void __setNoDelete(bool);
-
-private:
-
-#ifdef ICE_USE_MUTEX_SHARED
- int _ref;
- Mutex _mutex;
-#elif defined(_WIN32)
- LONG _ref;
-#else
- ice_atomic_t _ref;
-#endif
- bool _noDelete;
-};
-
-//
-// TODO: Not all operations below are performance critical, thus not
-// all of them should be inlined.
-//
-
-#ifdef ICE_USE_MUTEX_SHARED
-
-inline
-Shared::Shared() :
- _ref(0),
- _noDelete(false)
-{
-}
-
-inline
-Shared::~Shared()
-{
-}
-
-inline void
-Shared::__incRef()
-{
- _mutex.lock();
- assert(_ref >= 0);
- ++_ref;
- _mutex.unlock();
-}
-
-inline void
-Shared::__decRef()
-{
- _mutex.lock();
- bool doDelete = false;
- assert(_ref > 0);
- if(--_ref == 0)
- {
- doDelete = !_noDelete;
- }
- _mutex.unlock();
- if(doDelete)
- {
- delete this;
- }
-}
-
-inline int
-Shared::__getRef() const
-{
- _mutex.lock();
- int ref = _ref;
- _mutex.unlock();
- return ref;
-}
-
-inline void
-Shared::__setNoDelete(bool b)
-{
- _mutex.lock();
- _noDelete = b;
- _mutex.unlock();
-}
-
-#elif defined(_WIN32)
-
-inline
-Shared::Shared() :
- _ref(0),
- _noDelete(false)
-{
-}
-
-inline
-Shared::~Shared()
-{
-}
-
-inline void
-Shared::__incRef()
-{
- assert(InterlockedExchangeAdd(&_ref, 0) >= 0);
- InterlockedIncrement(&_ref);
-}
-
-inline void
-Shared::__decRef()
-{
- assert(InterlockedExchangeAdd(&_ref, 0) > 0);
- if(InterlockedDecrement(&_ref) == 0 && !_noDelete)
- {
- delete this;
- }
-}
-
-inline int
-Shared::__getRef() const
-{
- return InterlockedExchangeAdd(const_cast<LONG*>(&_ref), 0);
-}
-
-inline void
-Shared::__setNoDelete(bool b)
-{
- _noDelete = b;
-}
-
-#else
-
-inline
-Shared::Shared() :
- _noDelete(false)
-{
- ice_atomic_set(&_ref, 0);
-}
-
-inline
-Shared::~Shared()
-{
-}
-
-inline void
-Shared::__incRef()
-{
- assert(ice_atomic_exchange_add(0, &_ref) >= 0);
- ice_atomic_inc(&_ref);
-}
-
-inline void
-Shared::__decRef()
-{
- assert(ice_atomic_exchange_add(0, &_ref) > 0);
- if(ice_atomic_dec_and_test(&_ref) && !_noDelete)
- {
- delete this;
- }
-}
-
-inline int
-Shared::__getRef() const
-{
- return ice_atomic_exchange_add(0, const_cast<ice_atomic_t*>(&_ref));
-}
-
-inline void
-Shared::__setNoDelete(bool b)
-{
- _noDelete = b;
-}
-
-#endif
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_SHARED_H
+#define ICE_UTIL_SHARED_H
+
+#include <IceUtil/Config.h>
+
+//
+// The inline assembler causes problems with shared libraries.
+//
+#if defined(__ICC) && !defined(_WIN32)
+# define ICE_USE_MUTEX_SHARED
+#endif
+
+#ifdef ICE_USE_MUTEX_SHARED
+# include <IceUtil/Mutex.h>
+#endif
+
+#if !defined(_WIN32) && !defined(ICE_USE_MUTEX_SHARED)
+
+//
+// Linux only. Unfortunately, asm/atomic.h builds non-SMP safe code
+// with non-SMP kernels. This means that executables compiled with a
+// non-SMP kernel would fail randomly due to concurrency errors with
+// reference counting on SMP hosts. Therefore the relevent pieces of
+// atomic.h are more-or-less duplicated.
+//
+
+/*
+ * Make sure gcc doesn't try to be clever and move things around
+ * on us. We need to use _exactly_ the address the user gave us,
+ * not some alias that contains the same information.
+ */
+struct ice_atomic_t
+{
+ volatile int counter;
+};
+
+/*
+ * ice_atomic_set - set ice_atomic variable
+ * @v: pointer of type ice_atomic_t
+ * @i: required value
+ *
+ * Atomically sets the value of @v to @i. Note that the guaranteed
+ * useful range of an ice_atomic_t is only 24 bits.
+ */
+inline void ice_atomic_set(ice_atomic_t* v, int i)
+{
+ v->counter = i;
+}
+
+/*
+ * ice_atomic_inc - increment ice_atomic variable
+ * @v: pointer of type ice_atomic_t
+ *
+ * Atomically increments @v by 1. Note that the guaranteed useful
+ * range of an ice_atomic_t is only 24 bits.
+ *
+ * Inlined because this operation is performance critical.
+ */
+inline void ice_atomic_inc(ice_atomic_t *v)
+{
+ __asm__ __volatile__(
+ "lock ; incl %0"
+ :"=m" (v->counter)
+ :"m" (v->counter));
+}
+
+/**
+ * ice_atomic_dec_and_test - decrement and test
+ * @v: pointer of type ice_atomic_t
+ *
+ * Atomically decrements @v by 1 and returns true if the result is 0,
+ * or false for all other cases. Note that the guaranteed useful
+ * range of an ice_atomic_t is only 24 bits.
+ *
+ * Inlined because this operation is performance critical.
+ */
+inline int ice_atomic_dec_and_test(ice_atomic_t *v)
+{
+ unsigned char c;
+ __asm__ __volatile__(
+ "lock ; decl %0; sete %1"
+ :"=m" (v->counter), "=qm" (c)
+ :"m" (v->counter) : "memory");
+ return c != 0;
+}
+
+/**
+ * ice_atomic_exchange_add - same as InterlockedExchangeAdd. This
+ * didn't come from atomic.h (the code was derived from similar code
+ * in /usr/include/asm/rwsem.h)
+ *
+ * Inlined because this operation is performance critical.
+ */
+inline int ice_atomic_exchange_add(int i, ice_atomic_t* v)
+{
+ int tmp = i;
+ __asm__ __volatile__(
+ "lock ; xadd %0,(%2)"
+ :"+r"(tmp), "=m"(v->counter)
+ :"r"(v), "m"(v->counter)
+ : "memory");
+ return tmp + i;
+}
+
+#endif
+
+//
+// Base classes for reference counted types. The IceUtil::Handle
+// template can be used for smart pointers to types derived from these
+// bases.
+//
+// IceUtil::SimpleShared
+// =====================
+//
+// A non thread-safe base class for reference-counted types.
+//
+// IceUtil::Shared
+// ===============
+//
+// A thread-safe base class for reference-counted types.
+//
+namespace IceUtil
+{
+
+//
+// TODO: Not all operations in this class are performance critical,
+// thus not all of them should be inlined.
+//
+
+class SimpleShared : public noncopyable
+{
+public:
+
+ SimpleShared() :
+ _ref(0),
+ _noDelete(false)
+ {
+ }
+
+ virtual ~SimpleShared()
+ {
+ }
+
+ void __incRef()
+ {
+ assert(_ref >= 0);
+ ++_ref;
+ }
+
+ void __decRef()
+ {
+ assert(_ref > 0);
+ if(--_ref == 0)
+ {
+ if(!_noDelete)
+ {
+ delete this;
+ }
+ }
+ }
+
+ int __getRef() const
+ {
+ return _ref;
+ }
+
+ void __setNoDelete(bool b)
+ {
+ _noDelete = b;
+ }
+
+private:
+
+ int _ref;
+ bool _noDelete;
+};
+
+class Shared : public noncopyable
+{
+public:
+
+ Shared();
+ virtual ~Shared();
+ void __incRef();
+ void __decRef();
+ int __getRef() const;
+ void __setNoDelete(bool);
+
+private:
+
+#ifdef ICE_USE_MUTEX_SHARED
+ int _ref;
+ Mutex _mutex;
+#elif defined(_WIN32)
+ LONG _ref;
+#else
+ ice_atomic_t _ref;
+#endif
+ bool _noDelete;
+};
+
+//
+// TODO: Not all operations below are performance critical, thus not
+// all of them should be inlined.
+//
+
+#ifdef ICE_USE_MUTEX_SHARED
+
+inline
+Shared::Shared() :
+ _ref(0),
+ _noDelete(false)
+{
+}
+
+inline
+Shared::~Shared()
+{
+}
+
+inline void
+Shared::__incRef()
+{
+ _mutex.lock();
+ assert(_ref >= 0);
+ ++_ref;
+ _mutex.unlock();
+}
+
+inline void
+Shared::__decRef()
+{
+ _mutex.lock();
+ bool doDelete = false;
+ assert(_ref > 0);
+ if(--_ref == 0)
+ {
+ doDelete = !_noDelete;
+ }
+ _mutex.unlock();
+ if(doDelete)
+ {
+ delete this;
+ }
+}
+
+inline int
+Shared::__getRef() const
+{
+ _mutex.lock();
+ int ref = _ref;
+ _mutex.unlock();
+ return ref;
+}
+
+inline void
+Shared::__setNoDelete(bool b)
+{
+ _mutex.lock();
+ _noDelete = b;
+ _mutex.unlock();
+}
+
+#elif defined(_WIN32)
+
+inline
+Shared::Shared() :
+ _ref(0),
+ _noDelete(false)
+{
+}
+
+inline
+Shared::~Shared()
+{
+}
+
+inline void
+Shared::__incRef()
+{
+ assert(InterlockedExchangeAdd(&_ref, 0) >= 0);
+ InterlockedIncrement(&_ref);
+}
+
+inline void
+Shared::__decRef()
+{
+ assert(InterlockedExchangeAdd(&_ref, 0) > 0);
+ if(InterlockedDecrement(&_ref) == 0 && !_noDelete)
+ {
+ delete this;
+ }
+}
+
+inline int
+Shared::__getRef() const
+{
+ return InterlockedExchangeAdd(const_cast<LONG*>(&_ref), 0);
+}
+
+inline void
+Shared::__setNoDelete(bool b)
+{
+ _noDelete = b;
+}
+
+#else
+
+inline
+Shared::Shared() :
+ _noDelete(false)
+{
+ ice_atomic_set(&_ref, 0);
+}
+
+inline
+Shared::~Shared()
+{
+}
+
+inline void
+Shared::__incRef()
+{
+ assert(ice_atomic_exchange_add(0, &_ref) >= 0);
+ ice_atomic_inc(&_ref);
+}
+
+inline void
+Shared::__decRef()
+{
+ assert(ice_atomic_exchange_add(0, &_ref) > 0);
+ if(ice_atomic_dec_and_test(&_ref) && !_noDelete)
+ {
+ delete this;
+ }
+}
+
+inline int
+Shared::__getRef() const
+{
+ return ice_atomic_exchange_add(0, const_cast<ice_atomic_t*>(&_ref));
+}
+
+inline void
+Shared::__setNoDelete(bool b)
+{
+ _noDelete = b;
+}
+
+#endif
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Thread.h b/cpp/include/IceUtil/Thread.h
index 172c411c18c..2d96293bd23 100644
--- a/cpp/include/IceUtil/Thread.h
+++ b/cpp/include/IceUtil/Thread.h
@@ -1,117 +1,117 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_THREAD_H
-#define ICE_UTIL_THREAD_H
-
-#include <IceUtil/Shared.h>
-#include <IceUtil/Handle.h>
-
-namespace IceUtil
-{
-
-class Time;
-
-#ifdef _WIN32
-struct HandleWrapper : public Shared
-{
- // Inline for performance reasons.
- HandleWrapper(HANDLE h) :
- handle(h)
- {
- }
-
- // Inline for performance reasons.
- virtual ~HandleWrapper()
- {
- if(handle)
- {
- CloseHandle(handle);
- }
- }
-
- HANDLE handle;
-};
-
-typedef Handle<HandleWrapper> HandleWrapperPtr;
-#endif
-
-class ICE_UTIL_API ThreadControl
-{
-public:
-
- ThreadControl();
-
-#ifdef _WIN32
- ThreadControl(const HandleWrapperPtr&, unsigned);
-#else
- ThreadControl(pthread_t);
-#endif
-
- bool operator==(const ThreadControl&) const;
- 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.C alling join on a thread on which another thread is
- // already waiting for termination results in undefined behaviour.
- //
- void join();
-
- static void sleep(const Time&);
- static void yield();
-
-private:
-
-#ifdef _WIN32
- HandleWrapperPtr _handle;
- unsigned _id;
-#else
- pthread_t _id;
-#endif
-};
-
-class ICE_UTIL_API Thread : virtual public IceUtil::Shared
-{
-public:
-
- Thread();
- virtual ~Thread();
-
- virtual void run() = 0;
-
- ThreadControl start();
-
- ThreadControl getThreadControl();
-
- bool operator==(const Thread&) const;
- bool operator!=(const Thread&) const;
- bool operator<(const Thread&) const;
-
-private:
-
-#ifdef _WIN32
- unsigned _id;
- HandleWrapperPtr _handle;
-#else
- pthread_t _id;
-#endif
-};
-
-typedef Handle<Thread> ThreadPtr;
-
-}
-
-#endif
-
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_THREAD_H
+#define ICE_UTIL_THREAD_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Handle.h>
+
+namespace IceUtil
+{
+
+class Time;
+
+#ifdef _WIN32
+struct HandleWrapper : public Shared
+{
+ // Inline for performance reasons.
+ HandleWrapper(HANDLE h) :
+ handle(h)
+ {
+ }
+
+ // Inline for performance reasons.
+ virtual ~HandleWrapper()
+ {
+ if(handle)
+ {
+ CloseHandle(handle);
+ }
+ }
+
+ HANDLE handle;
+};
+
+typedef Handle<HandleWrapper> HandleWrapperPtr;
+#endif
+
+class ICE_UTIL_API ThreadControl
+{
+public:
+
+ ThreadControl();
+
+#ifdef _WIN32
+ ThreadControl(const HandleWrapperPtr&, unsigned);
+#else
+ ThreadControl(pthread_t);
+#endif
+
+ bool operator==(const ThreadControl&) const;
+ 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.C alling join on a thread on which another thread is
+ // already waiting for termination results in undefined behaviour.
+ //
+ void join();
+
+ static void sleep(const Time&);
+ static void yield();
+
+private:
+
+#ifdef _WIN32
+ HandleWrapperPtr _handle;
+ unsigned _id;
+#else
+ pthread_t _id;
+#endif
+};
+
+class ICE_UTIL_API Thread : virtual public IceUtil::Shared
+{
+public:
+
+ Thread();
+ virtual ~Thread();
+
+ virtual void run() = 0;
+
+ ThreadControl start();
+
+ ThreadControl getThreadControl();
+
+ bool operator==(const Thread&) const;
+ bool operator!=(const Thread&) const;
+ bool operator<(const Thread&) const;
+
+private:
+
+#ifdef _WIN32
+ unsigned _id;
+ HandleWrapperPtr _handle;
+#else
+ pthread_t _id;
+#endif
+};
+
+typedef Handle<Thread> ThreadPtr;
+
+}
+
+#endif
+
diff --git a/cpp/include/IceUtil/ThreadException.h b/cpp/include/IceUtil/ThreadException.h
index 9d4cdc9ad6d..5e9b409f556 100644
--- a/cpp/include/IceUtil/ThreadException.h
+++ b/cpp/include/IceUtil/ThreadException.h
@@ -1,47 +1,47 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_THREAD_EXCEPTION_H
-#define ICE_UTIL_THREAD_EXCEPTION_H
-
-#include <IceUtil/Exception.h>
-
-namespace IceUtil
-{
-
-class ICE_UTIL_API ThreadSyscallException : public Exception
-{
-public:
-
- ThreadSyscallException(const char*, int);
- virtual std::string ice_name() const;
- virtual void ice_print(std::ostream&) const;
- virtual Exception* ice_clone() const;
- virtual void ice_throw() const;
-
-private:
-
- const int _error;
-};
-
-class ICE_UTIL_API ThreadLockedException : public Exception
-{
-public:
-
- ThreadLockedException(const char*, int);
- virtual std::string ice_name() const;
- virtual Exception* ice_clone() const;
- virtual void ice_throw() const;
-};
-
-}
-
-#endif
-
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_THREAD_EXCEPTION_H
+#define ICE_UTIL_THREAD_EXCEPTION_H
+
+#include <IceUtil/Exception.h>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API ThreadSyscallException : public Exception
+{
+public:
+
+ ThreadSyscallException(const char*, int);
+ virtual std::string ice_name() const;
+ virtual void ice_print(std::ostream&) const;
+ virtual Exception* ice_clone() const;
+ virtual void ice_throw() const;
+
+private:
+
+ const int _error;
+};
+
+class ICE_UTIL_API ThreadLockedException : public Exception
+{
+public:
+
+ ThreadLockedException(const char*, int);
+ virtual std::string ice_name() const;
+ virtual Exception* ice_clone() const;
+ virtual void ice_throw() const;
+};
+
+}
+
+#endif
+
diff --git a/cpp/include/IceUtil/Time.h b/cpp/include/IceUtil/Time.h
index 241919dbb8a..ad59dd847b6 100644
--- a/cpp/include/IceUtil/Time.h
+++ b/cpp/include/IceUtil/Time.h
@@ -1,63 +1,63 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_TIME_H
-#define ICE_UTIL_TIME_H
-
-#include <IceUtil/Config.h>
-
-namespace IceUtil
-{
-
-class ICE_UTIL_API Time
-{
-public:
-
- Time();
-
- // No copy constructor and assignment operator necessary. The
- // automatically generated copy constructor and assignment
- // operator do the right thing.
-
- static Time now();
- static Time seconds(long);
- static Time milliSeconds(long);
-#ifdef _WIN32
- static Time microSeconds(__int64);
-#else
- static Time microSeconds(long long);
-#endif
-
- Time operator-() const;
- Time operator-(const Time&) const;
- Time operator+(const Time&) const;
- Time& operator+=(const Time&);
- Time& operator-=(const Time&);
-
- bool operator<(const Time&) const;
- bool operator<=(const Time&) const;
- bool operator>(const Time&) const;
- bool operator>=(const Time&) const;
- bool operator==(const Time&) const;
- bool operator!=(const Time&) const;
-
- operator timeval() const;
- operator double() const;
-
-private:
-
- Time(Int64);
-
- Int64 _usec;
-};
-
-} // End namespace IceUtil
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_TIME_H
+#define ICE_UTIL_TIME_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API Time
+{
+public:
+
+ Time();
+
+ // No copy constructor and assignment operator necessary. The
+ // automatically generated copy constructor and assignment
+ // operator do the right thing.
+
+ static Time now();
+ static Time seconds(long);
+ static Time milliSeconds(long);
+#ifdef _WIN32
+ static Time microSeconds(__int64);
+#else
+ static Time microSeconds(long long);
+#endif
+
+ Time operator-() const;
+ Time operator-(const Time&) const;
+ Time operator+(const Time&) const;
+ Time& operator+=(const Time&);
+ Time& operator-=(const Time&);
+
+ bool operator<(const Time&) const;
+ bool operator<=(const Time&) const;
+ bool operator>(const Time&) const;
+ bool operator>=(const Time&) const;
+ bool operator==(const Time&) const;
+ bool operator!=(const Time&) const;
+
+ operator timeval() const;
+ operator double() const;
+
+private:
+
+ Time(Int64);
+
+ Int64 _usec;
+};
+
+} // End namespace IceUtil
+
+#endif
diff --git a/cpp/include/IceUtil/UUID.h b/cpp/include/IceUtil/UUID.h
index 0c6ee035c08..2de0c61718f 100644
--- a/cpp/include/IceUtil/UUID.h
+++ b/cpp/include/IceUtil/UUID.h
@@ -1,23 +1,23 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_UUID_H
-#define ICE_UTIL_UUID_H
-
-#include <IceUtil/Config.h>
-
-namespace IceUtil
-{
-
-ICE_UTIL_API std::string generateUUID();
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_UUID_H
+#define ICE_UTIL_UUID_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+ICE_UTIL_API std::string generateUUID();
+
+}
+
+#endif
diff --git a/cpp/include/IceUtil/Unicode.h b/cpp/include/IceUtil/Unicode.h
index 6fb8e6304cd..ca4cd774750 100644
--- a/cpp/include/IceUtil/Unicode.h
+++ b/cpp/include/IceUtil/Unicode.h
@@ -1,24 +1,24 @@
-// **********************************************************************
-//
-// Copyright (c) 2001
-// Mutable Realms, Inc.
-// Huntsville, AL, USA
-//
-// All Rights Reserved
-//
-// **********************************************************************
-
-#ifndef ICE_UTIL_UNICODE_H
-#define ICE_UTIL_UNICODE_H
-
-#include <IceUtil/Config.h>
-
-namespace IceUtil
-{
-
-ICE_UTIL_API std::string wstringToString(const std::wstring&);
-ICE_UTIL_API std::wstring stringToWstring(const std::string&);
-
-}
-
-#endif
+// **********************************************************************
+//
+// Copyright (c) 2001
+// Mutable Realms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_UNICODE_H
+#define ICE_UTIL_UNICODE_H
+
+#include <IceUtil/Config.h>
+
+namespace IceUtil
+{
+
+ICE_UTIL_API std::string wstringToString(const std::wstring&);
+ICE_UTIL_API std::wstring stringToWstring(const std::string&);
+
+}
+
+#endif
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 16:37:16 +0000