zeroc-ice 3.6.5 → 3.7.4

data/ext/ValueFactoryManager.h

@@ -0,0 +1,95 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_RUBY_OBJECT_FACTORY_H
+#define ICE_RUBY_OBJECT_FACTORY_H
+
+#include <Config.h>
+#include <Ice/ValueFactory.h>
+#include <IceUtil/Mutex.h>
+
+namespace IceRuby
+{
+
+bool initValueFactoryManager(VALUE);
+
+class FactoryWrapper : public Ice::ValueFactory
+{
+public:
+
+    FactoryWrapper(VALUE, bool);
+
+    virtual Ice::ValuePtr create(const std::string&);
+
+    VALUE getObject() const;
+
+    bool isObjectFactory() const;
+
+    void mark();
+
+    void destroy();
+
+protected:
+
+    VALUE _factory;
+    bool _isObjectFactory;
+};
+typedef IceUtil::Handle<FactoryWrapper> FactoryWrapperPtr;
+
+class DefaultValueFactory : public Ice::ValueFactory
+{
+public:
+
+    virtual Ice::ValuePtr create(const std::string&);
+
+    void setDelegate(const Ice::ValueFactoryPtr&);
+    Ice::ValueFactoryPtr getDelegate() const { return _delegate; }
+
+    VALUE getObject() const;
+
+    void mark();
+
+    void destroy();
+
+private:
+
+    Ice::ValueFactoryPtr _delegate;
+};
+typedef IceUtil::Handle<DefaultValueFactory> DefaultValueFactoryPtr;
+
+class ValueFactoryManager : public Ice::ValueFactoryManager, public IceUtil::Mutex
+{
+public:
+
+    ValueFactoryManager();
+    ~ValueFactoryManager();
+
+    virtual void add(const Ice::ValueFactoryPtr&, const std::string&);
+    virtual Ice::ValueFactoryPtr find(const std::string&) const ICE_NOEXCEPT;
+
+    void addValueFactory(VALUE, const std::string&);
+    VALUE findValueFactory(const std::string&) const;
+    void addObjectFactory(VALUE, const std::string&);
+    VALUE findObjectFactory(const std::string&) const;
+
+    void mark();
+    void markSelf();
+
+    VALUE getObject() const;
+
+    void destroy();
+
+private:
+
+    typedef std::map<std::string, Ice::ValueFactoryPtr> FactoryMap;
+
+    VALUE _self;
+    FactoryMap _factories;
+    DefaultValueFactoryPtr _defaultFactory;
+};
+typedef IceUtil::Handle<ValueFactoryManager> ValueFactoryManagerPtr;
+
+}
+
+#endif

data/ext/extconf.rb

@@ -1,60 +1,52 @@
-# **********************************************************************
 #
-# Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
+# Copyright (c) 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.
-#
-# **********************************************************************
 
 require "mkmf"
+require "rbconfig"
 
-if ! (RUBY_PLATFORM =~ /mswin|mingw/)
-        if not have_header("bzlib.h") then
-            exit 1
-        end
+if RUBY_PLATFORM =~ /mswin|mingw/
+    puts "MinGW is not supported with Ice for Ruby."
+    exit 1
+end
+
+#
+# On OSX & Linux bzlib.h is required.
+#
+if not have_header("bzlib.h") then
+    exit 1
 end
 
 if RUBY_PLATFORM =~ /linux/
-	#
-	# On Linux openssl is required for IceSSL.
-	#
-	if not have_header("openssl/ssl.h") then
-	    exit 1
-	end
+    #
+    # On Linux openssl is required for IceSSL.
+    #
+    if not have_header("openssl/ssl.h") then
+        exit 1
+    end
 end
 
 #
 # Ice on OSX is built only with 64 bit support.
 #
 if RUBY_PLATFORM =~ /darwin/
-	$ARCH_FLAG = "-arch x86_64"
+    $ARCH_FLAG = "-arch x86_64"
+    # Make sure to use the SDK from Xcode (required for Sierra where old system headers can be used otherwise)
+    RbConfig::MAKEFILE_CONFIG['CC'] = 'xcrun -sdk macosx clang'
+    RbConfig::MAKEFILE_CONFIG['CXX'] = 'xcrun -sdk macosx clang++'
 end
 
 $INCFLAGS << ' -Iice/cpp/include'
+$INCFLAGS << ' -Iice/cpp/include/generated'
 $INCFLAGS << ' -Iice/cpp/src'
 
 $CPPFLAGS << ' -DICE_STATIC_LIBS'
+$CPPFLAGS << ' -DICE_GEM'
 
-if RUBY_PLATFORM =~ /mswin|mingw/
-	# Change -D_WIN32_WINNT=0x0501 to # Change -D_WIN32_WINNT=0x0601 otherwise the IceSSL plugin won't compile
-	$CPPFLAGS = $CPPFLAGS.sub("501", "601")
-
-	$CPPFLAGS << ' -DWIN32_LEAN_AND_MEAN'
-	$CPPFLAGS << ' -DICE_BUILDING_ICEUTIL'
-	$CPPFLAGS << ' -DICE_BUILDING_SLICE'
-	$CPPFLAGS << ' -DICE_BUILDING_ICE'
-	$CPPFLAGS << ' -DICE_BUILDING_ICESSL'
-	$CPPFLAGS << ' -mthreads'
-
-	# -lws2_32 must be in LOCAL_LIBS even though mkmk puts it at the end of the LIBS, otherwise
-	# you get error 6 when using the socket library.
-	$LOCAL_LIBS << ' -lbz2 -lShlwapi -lrpcrt4  -ladvapi32 -lIphlpapi -lsecur32 -lcrypt32 -lws2_32'
-
-elsif RUBY_PLATFORM =~ /darwin/
-	$LOCAL_LIBS << ' -framework Security -framework CoreFoundation'
+if RUBY_PLATFORM =~ /darwin/
+    $LOCAL_LIBS << ' -framework Security -framework CoreFoundation'
 elsif RUBY_PLATFORM =~ /linux/
-	$LOCAL_LIBS << ' -lssl -lcrypto -lbz2 -lrt'
+    $LOCAL_LIBS << ' -lssl -lcrypto -lbz2 -lrt'
         if RUBY_VERSION =~ /1.8/
             # With 1.8 we need to link with C++ runtime, as gcc is used to link the extension
             $LOCAL_LIBS << ' -lstdc++'
@@ -75,27 +67,39 @@ $srcs = []
 
 # Add the plugin source.
 Dir["*.cpp"].each do |f|
-	$objs << File.basename(f, ".*") + ".o"
-	$srcs << f
+    $objs << File.basename(f, ".*") + ".o"
+    $srcs << f
 end
 
-# The Ice source.
-skip = []
-if RUBY_PLATFORM =~ /mswin|mingw/
-	skip << "SysLoggerI.cpp"
+def filter(f)
+    #
+    # Filter IceSSL sources that doesn't match current OS default
+    # implementation
+    #
+    if f.start_with?("SChannel") or f.start_with?("UWP")
+        return false
+    end
+    if RUBY_PLATFORM =~ /darwin/ and f.start_with?("OpenSSL")
+        return false
+    end
+    if !(RUBY_PLATFORM =~ /darwin/) and f.start_with?("SecureTransport")
+         return false
+    end
+    return true
 end
+
 Dir["ice/**/*.cpp"].each do |f|
-	if ! skip.include? File.basename(f)
-		$objs << File.dirname(f) + "/" + File.basename(f, ".*") + ".o"
-		$srcs << f
-	end
+    if filter File.basename(f)
+        $objs << File.dirname(f) + "/" + File.basename(f, ".*") + ".o"
+        $srcs << f
+    end
 end
 
 # The mcpp source.
 Dir["ice/mcpp/*.c"].each do |f|
-	dir = "ice/mcpp"
-	$objs << File.join(dir, File.basename(f, ".*") + ".o")
-	$srcs << File.join(dir, f)
+    dir = "ice/mcpp"
+    $objs << File.join(dir, File.basename(f, ".*") + ".o")
+    $srcs << File.join(dir, f)
 end
 
 create_makefile "IceRuby"

data/ext/ice/cpp/include/Ice/Application.h

@@ -1,154 +1,324 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_APPLICATION_H
 #define ICE_APPLICATION_H
 
-#include <Ice/Ice.h>
-
+#include <Ice/Initialize.h>
 #include <IceUtil/Mutex.h>
+#include <IceUtil/Cond.h>
+#include <IceUtil/CtrlCHandler.h>
 
 namespace Ice
 {
-    enum SignalPolicy { HandleSignals, NoSignalHandling } ;
-    class Application;
-}
-
-namespace IceInternal
-{
-    
-namespace Application
-{
-    extern ICE_API IceUtil::Mutex* mutex;
-    extern ICE_API IceUtil::Cond* _condVar;
-
-    //
-    // Variables than can change while run() and communicator->destroy() are running!
-    //
-    extern ICE_API bool _callbackInProgress;
-    extern ICE_API bool _destroyed;
-    extern ICE_API bool _interrupted;
-    
-    //
-    // Variables that are immutable during run() and until communicator->destroy() has returned;
-    // before and after run(), and once communicator->destroy() has returned, we assume that 
-    // only the main thread and CtrlCHandler threads are running.
-    //
-    extern ICE_API std::string _appName;
-    extern ICE_API Ice::CommunicatorPtr _communicator;
-    extern ICE_API Ice::SignalPolicy _signalPolicy;
-    extern ICE_API Ice::Application* _application;
-}
 
-}
+using IceUtil::CtrlCHandler;
+using IceUtil::CtrlCHandlerCallback;
 
-namespace Ice
+#ifdef ICE_CPP11_MAPPING
+/**
+ * Determines how the Application class handles signals.
+ */
+enum class SignalPolicy : unsigned char
+#else
+enum SignalPolicy
+#endif
 {
+    /** Enables signal handling. */
+    HandleSignals,
+    /** Disables signal handling, meaning signals retain their default behavior. */
+    NoSignalHandling
+};
 
-class ICE_API Application : private IceUtil::noncopyable
+/**
+ * Singleton helper class that simplifies Ice initialization, finalization and signal handling.
+ * An application uses this class by writing a subclass and implementing the run method.
+ * \headerfile Ice/Ice.h
+ */
+class ICE_API Application
 {
 public:
 
-    Application(SignalPolicy = HandleSignals);
+    /**
+     * The constructor configures the signal handling behavior.
+     * @param policy Specifies whether to handle signals. If not specified, the default behavior
+     * is to handle signals.
+     */
+    Application(SignalPolicy policy = ICE_ENUM(SignalPolicy, HandleSignals));
+
+#ifdef ICE_CPP11_MAPPING
+    /// \cond IGNORE
+    Application(const Application&) = delete;
+    Application& operator=(const Application&) = delete;
+    /// \endcond
+#endif
+
     virtual ~Application();
 
-    //
-    // This main() must be called by the global main(). main()
-    // initializes the Communicator, calls run() as a template method,
-    // and destroys the Communicator upon return from run(). It
-    // thereby handles all exceptions properly, i.e., error messages
-    // are printed if exceptions propagate to main(), and the
-    // Communicator is always destroyed, regardless of exceptions.
-    //
-    int main(int, char*[], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, char*[], const char*);
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param argc Specifies the number of arguments in argv.
+     * @param argv The command-line arguments.
+     * @param initData Configuration data for the new Communicator.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(int argc, const char* const argv[], const InitializationData& initData = InitializationData(),
+             int version = ICE_INT_VERSION);
 
-    int main(int, char* const [], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, char* const [], const char*);
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param argc Specifies the number of arguments in argv.
+     * @param argv The command-line arguments.
+     * @param configFile The name of an Ice configuration file.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(int argc, const char* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
 #ifdef _WIN32
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param argc Specifies the number of arguments in argv.
+     * @param argv The command-line arguments.
+     * @param initData Configuration data for the new Communicator.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(int argc, const wchar_t* const argv[], const InitializationData& initData = InitializationData(),
+             int version = ICE_INT_VERSION);
 
-    int main(int, wchar_t*[], const Ice::InitializationData& = Ice::InitializationData());
-    int main(int, wchar_t*[], const char*);
-
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param argc Specifies the number of arguments in argv.
+     * @param argv The command-line arguments.
+     * @param configFile The name of an Ice configuration file.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(int argc, const wchar_t* const argv[], ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 #endif
 
-    int main(const StringSeq&, const Ice::InitializationData& = Ice::InitializationData());
-    int main(const StringSeq&, const char*);
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param args The command-line arguments.
+     * @param initData Configuration data for the new Communicator.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(const StringSeq& args, const InitializationData& initData = InitializationData(),
+             int version = ICE_INT_VERSION);
 
-    virtual int run(int, char*[]) = 0;
+    /**
+     * Call this main() from the global main(). main()
+     * initializes the Communicator, calls run() and destroys the
+     * the Communicator upon return from run(). It handles all
+     * exceptions properly, i.e., error message are printed if
+     * exceptions propagate to main(), and the Communicator is always
+     * destroyed, regardless of exceptions.
+     * @param args The command-line arguments.
+     * @param configFile The name of an Ice configuration file.
+     * @param version Indicates the Ice version with which the application is compatible. If not
+     * specified, the version of the Ice installation is used.
+     * @return The application's exit status.
+     */
+    int main(const StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version = ICE_INT_VERSION);
 
-    //
-    // Override this to provide a custom application interrupt
-    // hook. You must call callbackOnInterrupt for this method to
-    // be called. Note that the interruptCallback can be called
-    // concurrently with any other thread (including main) in your
-    // application and thus must take appropriate concurrency
-    // precautions.
-    //
-    virtual void interruptCallback(int);
+    /**
+     * run is given a copy of the remaining argc/argv arguments,
+     * after the communicator initialization in the caller (main)
+     * has removed all Ice-related arguments.
+     * @param argc Specifies the number of arguments in argv.
+     * @param argv The command-line arguments.
+     * @return The application's exit status.
+     */
+    virtual int run(int argc, char* argv[]) = 0;
 
-    //
-    // Return the application name, i.e., argv[0].
-    //
+    /**
+     * Override this method to provide a custom application interrupt
+     * hook. You must call callbackOnInterrupt for this method to
+     * be called. Note that the interruptCallback can be called
+     * concurrently with any other thread (including main) in your
+     * application and thus must take appropriate concurrency
+     * precautions.
+     * @param signal The signal identifier.
+     */
+    virtual void interruptCallback(int signal);
+
+    /**
+     * Obtains the application name, i.e., argv[0].
+     * @return The application's name.
+     */
     static const char* appName();
 
-    //
-    // One limitation of this class is that there can only be one
-    // Application instance, with one global Communicator, accessible
-    // with this communicator() operation. This limitation is due to
-    // how the signal handling functions below operate. If you require
-    // multiple Communicators, then you cannot use this Application
-    // framework class.
-    //
+    /**
+     * Obtains the application's Communicator instance.
+     * One limitation of this class is that there can only be one
+     * Application instance, with one global Communicator, accessible
+     * with this communicator() operation. This limitation is due to
+     * how the signal handling functions below operate. If you require
+     * multiple Communicators, then you cannot use this Application
+     * framework class.
+     * @return The application's communicator.
+     */
     static CommunicatorPtr communicator();
 
-    //
-    // These methods can be used to set a Ctrl+C Handler callback.
-    //
+    /**
+     * Configures the application to destroy the communicator when one of the
+     * monitored signals is raised. This is the default behavior.
+     */
     static void destroyOnInterrupt();
+
+    /**
+     * Configures the application to shut down the communicator when one of the
+     * monitored signals is raised.
+     */
     static void shutdownOnInterrupt();
+
+    /**
+     * Configures the application to ignore signals.
+     */
     static void ignoreInterrupt();
+
+    /**
+     * Configures the application to invoke interruptCallback when a signal occurs,
+     * thereby giving the subclass responsibility for handling the signal.
+     */
     static void callbackOnInterrupt();
 
-    //
-    // These methods can be used to temporarily block a signal and
-    // arrange for delivery of a pending signal later. Any signal that
-    // is received after holdInterrupt() was called is remembered and
-    // delivered when releaseInterupt() is called. That signal is then
-    // handled according to the signal disposition established with
-    // destroyOnInterrupt(), shutdownOnInterrupt() or
-    // ignoreInterrupt().
-    //
+    /**
+     * Configures the application to ignore (but remember) a signal.
+     * A stored signal (if any) can be handled later by calling releaseInterrupt.
+     */
     static void holdInterrupt();
+
+    /**
+     * Processes a stored signal (if any) using the current signal handling configuration.
+     */
     static void releaseInterrupt();
 
-    //
-    // This method returns true if a signal handler was triggered,
-    // false otherwise. This can be used once
-    // Communicator::waitForShutdown() returns to test whether the
-    // shutdown was due to an interrupt (interrupted() returns true in
-    // that case) or because Communicator::shutdown() was called
-    // (interrupted() returns false in that case).
-    //
+    /**
+     * Indicates whether a signal handler was triggered.
+     * This can be used once Communicator::waitForShutdown() returns to
+     * test whether the shutdown was due to an interrupt (returns true)
+     * or because Communicator::shutdown() was called (returns false).
+     * @return True if a signal handler was triggered, false otherwise.
+     */
     static bool interrupted();
 
 protected:
 
-    virtual int doMain(int, char*[], const Ice::InitializationData&);
+    /**
+     * Helper function that implements the application logic.
+     */
+    virtual int doMain(int, char*[], const InitializationData&, Int);
 
-#if defined(__SUNPRO_CC)
-//
-// Sun C++ 5.x does not like classes with no data members 
-//
-    char _dummy;
+    /**
+     * Used to synchronize the main thread and the CtrlCHandler thread.
+     */
+    static IceUtil::Mutex _mutex;
+
+    /**
+     * Used to synchronize the main thread and the CtrlCHandler thread.
+     */
+    static IceUtil::Cond _condVar;
+
+    /**
+     * True if a signal handling callback is currently executing.
+     * Can change while run() and communicator->destroy() are running!
+     */
+    static bool _callbackInProgress;
+
+    /**
+     * True if the communicator has been destroyed.
+     * Can change while run() and communicator->destroy() are running!
+     */
+    static bool _destroyed;
+
+    /**
+     * True if an interrupt signal was received.
+     * Can change while run() and communicator->destroy() are running!
+     */
+    static bool _interrupted;
+
+    /**
+     * The application's name.
+     * Immutable during run() and until communicator->destroy() has returned.
+     * Before and after run(), and once communicator->destroy() has returned,
+     * we assume that only the main thread and CtrlCHandler threads are running.
+     */
+    static std::string _appName;
+
+    /**
+     * The application's communicator.
+     * Immutable during run() and until communicator->destroy() has returned.
+     * Before and after run(), and once communicator->destroy() has returned,
+     * we assume that only the main thread and CtrlCHandler threads are running.
+     */
+    static CommunicatorPtr _communicator;
+
+    /**
+     * The signal-handling policy specified at construction.
+     * Immutable during run() and until communicator->destroy() has returned.
+     * Before and after run(), and once communicator->destroy() has returned,
+     * we assume that only the main thread and CtrlCHandler threads are running.
+     */
+    static SignalPolicy _signalPolicy;
+
+    /**
+     * The singleton instance.
+     * Immutable during run() and until communicator->destroy() has returned.
+     * Before and after run(), and once communicator->destroy() has returned,
+     * we assume that only the main thread and CtrlCHandler threads are running.
+     */
+    static Application* _application;
+
+private:
+
+    static void holdInterruptCallback(int);
+    static void destroyOnInterruptCallback(int);
+    static void shutdownOnInterruptCallback(int);
+    static void callbackOnInterruptCallback(int);
+
+#ifndef ICE_CPP11_MAPPING
+    //
+    // Not defined, make Application non-copyable
+    //
+    Application(const Application&);
+    Application& operator=(const Application&);
 #endif
+
 };
 
 }