zeroc-ice 3.6b1

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

@@ -0,0 +1,91 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_STRING_UTIL_H
+#define ICE_STRING_UTIL_H
+
+#include <IceUtil/Config.h>
+#include <vector>
+
+namespace IceUtilInternal
+{
+
+//
+// Add escape sequences (like "\n", or "\0xxx") to make a string
+// readable in ASCII.
+//
+ICE_UTIL_API std::string escapeString(const std::string&, const std::string&);
+
+//
+// Remove escape sequences added by escapeString. Throws IllegalArgumentException
+// for an invalid input string.
+//
+ICE_UTIL_API std::string unescapeString(const std::string&, std::string::size_type, std::string::size_type);
+
+//
+// Split a string using the given delimiters. Considers single and double quotes;
+// returns false for unbalanced quote, true otherwise.
+//
+ICE_UTIL_API bool splitString(const std::string&, const std::string&, std::vector<std::string>&);
+
+//
+// Join a list of strings using the given delimiter. 
+//
+ICE_UTIL_API std::string joinString(const std::vector<std::string>&, const std::string&);
+
+//
+// Trim white space
+//
+ICE_UTIL_API std::string trim(const std::string&);
+
+//
+// If a single or double quotation mark is found at the start
+// position, then the position of the matching closing quote is
+// returned. If no quotation mark is found at the start position, then
+// 0 is returned. If no matching closing quote is found, then
+// std::string::npos is returned.
+//
+ICE_UTIL_API std::string::size_type checkQuote(const std::string&, std::string::size_type = 0);
+
+//
+// Match `s' against the pattern `pat'. A * in the pattern acts
+// as a wildcard: it matches any non-empty sequence of characters
+// other than a period (`.'). We match by hand here because
+// it's portable across platforms (whereas regex() isn't).
+//
+ICE_UTIL_API bool match(const std::string&, const std::string&, bool = false);
+
+//
+// Get the error message for the last error code or given error code.
+//
+ICE_UTIL_API std::string lastErrorToString();
+#ifdef _WIN32
+ICE_UTIL_API std::string errorToString(int, LPCVOID = NULL);
+#else
+ICE_UTIL_API std::string errorToString(int);
+#endif
+
+//
+// Functions to convert to lower/upper case. These functions accept
+// UTF8 string/characters but ignore non ASCII characters. Unlike, the
+// C methods, these methods are not local dependent.
+//
+ICE_UTIL_API std::string toLower(const std::string&);
+ICE_UTIL_API std::string toUpper(const std::string&);
+ICE_UTIL_API bool isAlpha(char);
+ICE_UTIL_API bool isDigit(char);
+
+//
+// Remove all whitespace from a string
+//
+ICE_UTIL_API std::string removeWhitespace(const std::string&);
+
+}
+
+#endif

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

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

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

@@ -0,0 +1,108 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_THREAD_EXCEPTION_H
+#define ICE_UTIL_THREAD_EXCEPTION_H
+
+#include <IceUtil/Exception.h>
+#include <IceUtil/Time.h>
+
+namespace IceUtil
+{
+
+class ICE_UTIL_API ThreadSyscallException : public SyscallException
+{
+public:
+
+    ThreadSyscallException(const char*, int, int);
+    virtual std::string ice_name() const;
+    virtual ThreadSyscallException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API ThreadLockedException : public Exception
+{
+public:
+
+    ThreadLockedException(const char*, int);
+    virtual std::string ice_name() const;
+    virtual ThreadLockedException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API ThreadStartedException : public Exception
+{
+public:
+
+    ThreadStartedException(const char*, int);
+    virtual std::string ice_name() const;
+    virtual ThreadStartedException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API ThreadNotStartedException : public Exception
+{
+public:
+
+    ThreadNotStartedException(const char*, int);
+    virtual std::string ice_name() const;
+    virtual ThreadNotStartedException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API BadThreadControlException : public Exception
+{
+public:
+
+    BadThreadControlException(const char*, int);
+    virtual std::string ice_name() const;
+    virtual BadThreadControlException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+
+    static const char* _name;
+};
+
+class ICE_UTIL_API InvalidTimeoutException : public Exception
+{
+public:
+
+    InvalidTimeoutException(const char*, int, const Time&);
+    virtual std::string ice_name() const;
+    virtual void ice_print(std::ostream&) const;
+    virtual InvalidTimeoutException* ice_clone() const;
+    virtual void ice_throw() const;
+
+private:
+    
+    Time _timeout;
+    static const char* _name;
+};
+    
+}
+
+#endif
+

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

@@ -0,0 +1,209 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 ZeroC, Inc. All rights reserved.
+//
+// This copy of Ice is licensed to you under the terms described in the
+// ICE_LICENSE file included in this distribution.
+//
+// **********************************************************************
+
+#ifndef ICE_UTIL_TIME_H
+#define ICE_UTIL_TIME_H
+
+#include <IceUtil/Config.h>
+
+#ifndef _WIN32
+#   include <sys/time.h>
+#endif
+
+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.
+    
+    enum Clock { Realtime, Monotonic };
+    static Time now(Clock = Realtime);
+
+    static Time seconds(Int64);
+    static Time milliSeconds(Int64);
+    static Time microSeconds(Int64);
+
+    static Time secondsDouble(double);
+    static Time milliSecondsDouble(double);
+    static Time microSecondsDouble(double);
+    
+#ifndef _WIN32
+    operator timeval() const;
+#endif
+
+    Int64 toSeconds() const;
+    Int64 toMilliSeconds() const;
+    Int64 toMicroSeconds() const;
+
+    double toSecondsDouble() const;
+    double toMilliSecondsDouble() const;
+    double toMicroSecondsDouble() const;
+
+    std::string toDateTime() const;
+    std::string toDuration() const;
+
+    Time operator-() const
+    {
+        return Time(-_usec);
+    }
+
+    Time operator-(const Time& rhs) const
+    {
+        return Time(_usec - rhs._usec);
+    }
+
+    Time operator+(const Time& rhs) const
+    {
+        return Time(_usec + rhs._usec);
+    }
+
+    Time& operator+=(const Time& rhs)
+    {
+        _usec += rhs._usec;
+        return *this;
+    }
+
+    Time& operator-=(const Time& rhs)
+    {
+        _usec -= rhs._usec;
+        return *this;
+    }
+
+    bool operator<(const Time& rhs) const
+    {
+        return _usec < rhs._usec;
+    }
+
+    bool operator<=(const Time& rhs) const
+    {
+        return _usec <= rhs._usec;
+    }
+
+    bool operator>(const Time& rhs) const
+    {
+        return _usec > rhs._usec;
+    }
+
+    bool operator>=(const Time& rhs) const
+    {
+        return _usec >= rhs._usec;
+    }
+
+    bool operator==(const Time& rhs) const
+    {
+        return _usec == rhs._usec;
+    }
+
+    bool operator!=(const Time& rhs) const
+    {
+        return _usec != rhs._usec;
+    }
+
+    double operator/(const Time& rhs) const
+    {
+        return static_cast<double>(_usec) / static_cast<double>(rhs._usec);
+    }
+
+    Time& operator*=(int rhs)
+    {
+        _usec *= rhs;
+        return *this;
+    }
+
+    Time operator*(int rhs) const
+    {
+        Time t;
+        t._usec = _usec * rhs;
+        return t;
+    }
+
+    Time& operator/=(int rhs)
+    {
+        _usec /= rhs;
+        return *this;
+    }
+
+    Time operator/(int rhs) const
+    {
+        Time t;
+        t._usec = _usec / rhs;
+        return t;
+    }
+
+    Time& operator*=(Int64 rhs)
+    {
+        _usec *= rhs;
+        return *this;
+    }
+
+    Time operator*(Int64 rhs) const
+    {
+        Time t;
+        t._usec = _usec * rhs;
+        return t;
+    }
+
+    Time& operator/=(Int64 rhs)
+    {
+        _usec /= rhs;
+        return *this;
+    }
+
+    Time operator/(Int64 rhs) const
+    {
+        Time t;
+        t._usec = _usec / rhs;
+        return t;
+    }
+
+    Time& operator*=(double rhs)
+    {
+        _usec = static_cast<Int64>(static_cast<double>(_usec) * rhs);
+        return *this;
+    }
+
+    Time operator*(double rhs) const
+    {
+        Time t;
+        t._usec = static_cast<Int64>(static_cast<double>(_usec) * rhs);
+        return t;
+    }
+
+    Time& operator/=(double rhs)
+    {
+        _usec = static_cast<Int64>(static_cast<double>(_usec) / rhs);
+        return *this;
+    }
+
+    Time operator/(double rhs) const
+    {
+        Time t;
+        t._usec = static_cast<Int64>(static_cast<double>(_usec) / rhs);
+        return t;
+    }
+
+private:
+
+    Time(Int64);
+
+    Int64 _usec;
+};
+
+ICE_UTIL_API std::ostream& operator<<(std::ostream&, const Time&);
+
+} // End namespace IceUtil
+
+#endif