zeroc-ice 3.7.10 → 3.7.11

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

@@ -0,0 +1,96 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_CTRL_C_HANDLER_H
+#define ICE_UTIL_CTRL_C_HANDLER_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Exception.h>
+
+#ifdef ICE_CPP11_MAPPING
+#   include <functional>
+#endif
+
+namespace IceUtil
+{
+
+/**
+ * Invoked when a signal occurs. The callback must not raise exceptions.
+ * On Linux and macOS, the callback is NOT a signal handler and can call
+ * functions that are not async-signal safe.
+ * @param sig The signal number that occurred.
+ */
+#ifdef ICE_CPP11_MAPPING
+using CtrlCHandlerCallback = std::function<void(int sig)>;
+#else
+typedef void (*CtrlCHandlerCallback)(int sig);
+#endif
+
+/**
+ * Provides a portable way to handle Ctrl-C and Ctrl-C like signals.
+ * On Linux and macOS, the CtrlCHandler handles SIGHUP, SIGINT and SIGTERM.
+ * On Windows, it is essentially a wrapper for SetConsoleCtrlHandler().
+ *
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API CtrlCHandler
+{
+public:
+
+     /**
+     * Registers a callback function that handles Ctrl-C like signals.
+     * On Linux and macOS, this constructor masks the SIGHUP, SIGINT and SIGTERM
+     * signals and then creates a thread that waits for these signals using sigwait.
+     * On Windows, this constructor calls SetConsoleCtrlCHandler to register a handler
+     * routine that calls the supplied callback function.
+     * Only a single CtrlCHandler object can exist in a process at a give time.
+     * @param cb The callback function to invoke when a signal is received.
+     */
+    explicit CtrlCHandler(CtrlCHandlerCallback cb = ICE_NULLPTR);
+
+     /**
+     * Unregisters the callback function.
+     * On Linux and macOS, this destructor joins and terminates the thread created
+     * by the constructor but does not "unmask" SIGHUP, SIGINT and SIGTERM. As a result,
+     * these signals are ignored after this destructor completes.
+     * On Windows, this destructor unregisters the SetConsoleCtrlHandler handler
+     * routine, and as a result a Ctrl-C or similar signal will terminate the application
+     * after this destructor completes.
+     */
+    ~CtrlCHandler();
+
+    /**
+     * Replaces the signal callback.
+     * @param cb The new callback.
+     * @return The old callback, or nil if no callback is currently set.
+     */
+    CtrlCHandlerCallback setCallback(CtrlCHandlerCallback cb);
+
+    /**
+     * Obtains the signal callback.
+     * @return The callback.
+     */
+    CtrlCHandlerCallback getCallback() const;
+};
+
+/**
+ * Raised by the CtrlCHandler constructor if another CtrlCHandler already exists.
+ *
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API CtrlCHandlerException : public ExceptionHelper<CtrlCHandlerException>
+{
+public:
+
+    CtrlCHandlerException(const char*, int);
+    virtual std::string ice_id() const;
+
+#ifndef ICE_CPP11_MAPPING
+    virtual CtrlCHandlerException* ice_clone() const;
+#endif
+};
+
+}
+
+#endif

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

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

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

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

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

@@ -0,0 +1,153 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_UTIL_TIMER_H
+#define ICE_UTIL_TIMER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/Monitor.h>
+#include <IceUtil/Time.h>
+
+#include <set>
+#include <map>
+#include <functional>
+
+namespace IceUtil
+{
+
+class Timer;
+typedef IceUtil::Handle<Timer> TimerPtr;
+
+//
+// Extend the TimerTask class and override the runTimerTask() method to execute
+// code at a specific time or repeatedly.
+//
+class ICE_API TimerTask
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
+{
+public:
+
+    virtual ~TimerTask();
+
+    virtual void runTimerTask() = 0;
+};
+ICE_DEFINE_PTR(TimerTaskPtr, TimerTask);
+
+//
+// The timer class is used to schedule tasks for one-time execution or
+// repeated execution. Tasks are executed by the dedicated timer thread
+// sequentially.
+//
+class ICE_API Timer : public virtual IceUtil::Shared, private IceUtil::Thread
+{
+public:
+
+    //
+    // Construct a timer and starts its execution thread.
+    //
+    Timer();
+
+    //
+    // Construct a timer and starts its execution thread with the priority.
+    //
+    Timer(int priority);
+
+    //
+    // Destroy the timer and detach its execution thread if the calling thread
+    // is the timer thread, join the timer execution thread otherwise.
+    //
+    void destroy();
+
+    //
+    // Schedule a task for execution after a given delay.
+    //
+    void schedule(const TimerTaskPtr&, const IceUtil::Time&);
+
+    //
+    // Schedule a task for repeated execution with the given delay
+    // between each execution.
+    //
+    void scheduleRepeated(const TimerTaskPtr&, const IceUtil::Time&);
+
+    //
+    // Cancel a task. Returns true if the task has not yet run or if
+    // it's a task scheduled for repeated execution. Returns false if
+    // the task has already run, was already cancelled or was never
+    // schedulded.
+    //
+    bool cancel(const TimerTaskPtr&);
+
+protected:
+
+    virtual void run();
+    virtual void runTimerTask(const TimerTaskPtr&);
+
+    struct Token
+    {
+        IceUtil::Time scheduledTime;
+        IceUtil::Time delay;
+        TimerTaskPtr task;
+
+        inline Token(const IceUtil::Time&, const IceUtil::Time&, const TimerTaskPtr&);
+        inline bool operator<(const Token& r) const;
+    };
+
+    IceUtil::Monitor<IceUtil::Mutex> _monitor;
+    bool _destroyed;
+    std::set<Token> _tokens;
+
+#ifdef __clang__
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations" // for std::binary_function below
+#endif
+
+#if (ICE_CPLUSPLUS >= 201703L)
+    class TimerTaskCompare
+#else
+    class TimerTaskCompare : public std::binary_function<TimerTaskPtr, TimerTaskPtr, bool>
+#endif
+    {
+    public:
+
+        bool operator()(const TimerTaskPtr& lhs, const TimerTaskPtr& rhs) const
+        {
+            return lhs.get() < rhs.get();
+        }
+    };
+    std::map<TimerTaskPtr, IceUtil::Time, TimerTaskCompare> _tasks;
+    IceUtil::Time _wakeUpTime;
+};
+typedef IceUtil::Handle<Timer> TimerPtr;
+
+#ifdef __clang__
+#   pragma clang diagnostic pop
+#endif
+
+inline
+Timer::Token::Token(const IceUtil::Time& st, const IceUtil::Time& d, const TimerTaskPtr& t) :
+    scheduledTime(st), delay(d), task(t)
+{
+}
+
+inline bool
+Timer::Token::operator<(const Timer::Token& r) const
+{
+    if(scheduledTime < r.scheduledTime)
+    {
+        return true;
+    }
+    else if(scheduledTime > r.scheduledTime)
+    {
+        return false;
+    }
+
+    return task.get() < r.task.get();
+}
+
+}
+
+#endif