zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Application.cpp

@@ -1,661 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/Application.h>
-#include <Ice/LoggerI.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/ArgVector.h>
-
-#ifdef _WIN32
-const DWORD SIGHUP = CTRL_LOGOFF_EVENT;
-#else
-#   include <csignal>
-#endif
-
-using namespace std;
-using namespace Ice;
-using namespace IceInternal;
-using namespace IceUtil;
-using namespace IceUtilInternal;
-
-//
-// static member initialization
-//
-IceUtil::Mutex Ice::Application::_mutex;
-IceUtil::Cond Ice::Application::_condVar;
-
-bool Ice::Application::_callbackInProgress = false;
-bool Ice::Application::_destroyed = false;
-bool Ice::Application::_interrupted = false;
-
-string Ice::Application::_appName;
-Ice::CommunicatorPtr Ice::Application::_communicator;
-Ice::SignalPolicy Ice::Application::_signalPolicy = ICE_ENUM(SignalPolicy, HandleSignals);
-Ice::Application* Ice::Application::_application = 0;
-
-namespace
-{
-
-//
-// Variables than can change while run() and communicator->destroy() are running!
-//
-bool _released = true;
-CtrlCHandlerCallback _previousCallback = ICE_NULLPTR;
-
-//
-// 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.
-//
-CtrlCHandler* _ctrlCHandler = 0;
-bool _nohup = false;
-
-}
-
-Ice::Application::Application(SignalPolicy signalPolicy)
-{
-    Ice::Application::_signalPolicy = signalPolicy;
-}
-
-Ice::Application::~Application()
-{
-}
-
-int
-Ice::Application::main(int argc, const char* const argv[], ICE_CONFIG_FILE_STRING configFile, int version)
-{
-    _appName = "";
-    if(argc > 0)
-    {
-        _appName = argv[0];
-    }
-
-    if(argc > 0 && argv[0] && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
-    {
-        setProcessLogger(ICE_MAKE_SHARED(LoggerI, argv[0], "", true));
-    }
-
-    InitializationData initData;
-#ifndef ICE_CPP11_MAPPING
-    if(configFile)
-#endif
-    {
-        try
-        {
-            initData.properties = createProperties();
-            initData.properties->load(configFile);
-        }
-        catch(const Ice::Exception& ex)
-        {
-            Error out(getProcessLogger());
-            out << ex;
-            return EXIT_FAILURE;
-        }
-        catch(const std::exception& ex)
-        {
-            Error out(getProcessLogger());
-            out << ex;
-            return EXIT_FAILURE;
-        }
-        catch(...)
-        {
-            Error out(getProcessLogger());
-            out << "unknown exception";
-            return EXIT_FAILURE;
-        }
-    }
-    return main(argc, argv, initData, version);
-}
-
-#ifdef _WIN32
-int
-Ice::Application::main(int argc, const wchar_t* const argv[], const Ice::InitializationData& initData, int version)
-{
-    //
-    // On Windows the given wchar_t* strings are UTF16 and therefore
-    // needs to be converted to native narrow string encoding.
-    //
-    return main(argsToStringSeq(argc, argv), initData, version);
-}
-
-int
-Ice::Application::main(int argc, const wchar_t* const argv[], ICE_CONFIG_FILE_STRING config, int version)
-{
-    return main(argsToStringSeq(argc, argv), config, version);
-}
-#endif
-
-int
-Ice::Application::main(int argc, const char* const argv[], const InitializationData& initializationData, int version)
-{
-    if(argc > 0 && argv[0] && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
-    {
-        const bool convert = initializationData.properties ?
-            initializationData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
-            initializationData.properties->getProperty("Ice.StdErr").empty() : true;
-        setProcessLogger(ICE_MAKE_SHARED(LoggerI, argv[0], "", convert));
-    }
-
-    if(_communicator != 0)
-    {
-        Error out(getProcessLogger());
-        out << "only one instance of the Application class can be used";
-        return EXIT_FAILURE;
-    }
-    int status;
-
-    ArgVector av(argc, argv); // copy args
-
-    //
-    // We parse the properties here to extract Ice.ProgramName.
-    //
-    InitializationData initData = initializationData;
-    try
-    {
-        initData.properties = createProperties(av.argc, av.argv, initData.properties);
-    }
-    catch(const Ice::Exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << ex;
-        return EXIT_FAILURE;
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << ex;
-        return EXIT_FAILURE;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "unknown exception";
-        return EXIT_FAILURE;
-    }
-    _appName = initData.properties->getPropertyWithDefault("Ice.ProgramName", _appName);
-
-    //
-    // Used by destroyOnInterruptCallback and shutdownOnInterruptCallback.
-    //
-    _nohup = initData.properties->getPropertyAsInt("Ice.Nohup") > 0;
-
-    _application = this;
-
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        try
-        {
-            //
-            // The ctrlCHandler must be created before starting any thread, in particular
-            // before initializing the communicator.
-            //
-            CtrlCHandler ctrCHandler;
-            _ctrlCHandler = &ctrCHandler;
-
-            status = doMain(av.argc, av.argv, initData, version);
-
-            //
-            // Set _ctrlCHandler to 0 only once communicator->destroy() has completed.
-            //
-            _ctrlCHandler = 0;
-        }
-        catch(const CtrlCHandlerException&)
-        {
-            Error out(getProcessLogger());
-            out << "only one instance of the CtrlCHandler class can be used";
-            status = EXIT_FAILURE;
-        }
-    }
-    else
-    {
-        status = doMain(av.argc, av.argv, initData, version);
-    }
-
-    return status;
-}
-
-int
-Ice::Application::main(const StringSeq& args, const InitializationData& initData, int version)
-{
-    ArgVector av(args);
-    return main(av.argc, av.argv, initData, version);
-}
-
-int
-Ice::Application::main(const StringSeq& args, ICE_CONFIG_FILE_STRING configFile, int version)
-{
-    ArgVector av(args);
-    return main(av.argc, av.argv, configFile, version);
-}
-
-void
-Ice::Application::interruptCallback(int)
-{
-}
-
-const char*
-Ice::Application::appName()
-{
-    return _appName.c_str();
-}
-
-CommunicatorPtr
-Ice::Application::communicator()
-{
-    return _communicator;
-}
-
-void
-Ice::Application::destroyOnInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(!_released)
-            {
-                _released = true;
-                _condVar.signal();
-            }
-            _ctrlCHandler->setCallback(destroyOnInterruptCallback);
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-void
-Ice::Application::shutdownOnInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(!_released)
-            {
-                _released = true;
-                _condVar.signal();
-            }
-            _ctrlCHandler->setCallback(shutdownOnInterruptCallback);
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-void
-Ice::Application::ignoreInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(!_released)
-            {
-                _released = true;
-                _condVar.signal();
-            }
-            _ctrlCHandler->setCallback(0);
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-void
-Ice::Application::callbackOnInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(!_released)
-            {
-                _released = true;
-                _condVar.signal();
-            }
-            _ctrlCHandler->setCallback(callbackOnInterruptCallback);
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-void
-Ice::Application::holdInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(_released)
-            {
-                _released = false;
-                _previousCallback = _ctrlCHandler->setCallback(holdInterruptCallback);
-            }
-            // else, we were already holding signals
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-void
-Ice::Application::releaseInterrupt()
-{
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        if(_ctrlCHandler != 0)
-        {
-            Mutex::Lock lock(_mutex); // we serialize all the interrupt-setting
-            if(!_released)
-            {
-                //
-                // Note that it's very possible no signal is held;
-                // in this case the callback is just replaced and
-                // setting _released to true and signalling _condVar
-                // do no harm.
-                //
-
-                _released = true;
-                _ctrlCHandler->setCallback(_previousCallback);
-                _condVar.signal();
-            }
-            // Else nothing to release.
-        }
-    }
-    else
-    {
-        Warning out(getProcessLogger());
-        out << "interrupt method called on Application configured to not handle interrupts.";
-    }
-}
-
-bool
-Ice::Application::interrupted()
-{
-    Mutex::Lock lock(_mutex);
-    return _interrupted;
-}
-
-int
-Ice::Application::doMain(int argc, char* argv[], const InitializationData& initData, int version)
-{
-    int status;
-
-    try
-    {
-        _interrupted = false;
-
-        //
-        // If the process logger is the default logger, we now replace it with a
-        // a logger which is using the program name for the prefix.
-        //
-        if(initData.properties->getProperty("Ice.ProgramName") != "" && ICE_DYNAMIC_CAST(LoggerI, getProcessLogger()))
-        {
-            const bool convert =
-                initData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
-                initData.properties->getProperty("Ice.StdErr").empty();
-
-            setProcessLogger(ICE_MAKE_SHARED(LoggerI, initData.properties->getProperty("Ice.ProgramName"), "", convert));
-        }
-
-        _communicator = initialize(argc, argv, initData, version);
-        _destroyed = false;
-
-        //
-        // The default is to destroy when a signal is received.
-        //
-        if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-        {
-            destroyOnInterrupt();
-        }
-
-        status = run(argc, argv);
-    }
-    catch(const Ice::Exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << ex;
-        status = EXIT_FAILURE;
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << ex;
-        status = EXIT_FAILURE;
-    }
-    catch(const std::string& msg)
-    {
-        Error out(getProcessLogger());
-        out << msg;
-        status = EXIT_FAILURE;
-    }
-    catch(const char* msg)
-    {
-        Error out(getProcessLogger());
-        out << msg;
-        status = EXIT_FAILURE;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "unknown exception";
-        status = EXIT_FAILURE;
-    }
-
-    //
-    // Don't want any new interrupt and at this point (post-run),
-    // it would not make sense to release a held signal to run
-    // shutdown or destroy.
-    //
-    if(_signalPolicy == ICE_ENUM(SignalPolicy, HandleSignals))
-    {
-        ignoreInterrupt();
-    }
-
-    {
-        Mutex::Lock lock(_mutex);
-        while(_callbackInProgress)
-        {
-            _condVar.wait(lock);
-        }
-        if(_destroyed)
-        {
-            _communicator = 0;
-        }
-        else
-        {
-            _destroyed = true;
-            //
-            // And _communicator != 0, meaning will be destroyed
-            // next, _destroyed = true also ensures that any
-            // remaining callback won't do anything
-            //
-        }
-        _application = 0;
-    }
-
-    if(_communicator != 0)
-    {
-        _communicator->destroy();
-        _communicator = 0;
-    }
-
-    return status;
-}
-
-//
-// CtrlCHandler callbacks.
-//
-
-void
-Ice::Application::holdInterruptCallback(int signal)
-{
-    CtrlCHandlerCallback callback = ICE_NULLPTR;
-    {
-        Mutex::Lock lock(_mutex);
-        while(!_released)
-        {
-            _condVar.wait(lock);
-        }
-
-        if(_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        assert(_ctrlCHandler != 0);
-        callback = _ctrlCHandler->getCallback();
-    }
-
-    if(callback)
-    {
-        callback(signal);
-    }
-}
-
-void
-Ice::Application::destroyOnInterruptCallback(int signal)
-{
-    {
-        Mutex::Lock lock(_mutex);
-        if(_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        if(_nohup && signal == static_cast<int>(SIGHUP))
-        {
-            return;
-        }
-
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
-        _destroyed = true;
-    }
-
-    assert(_communicator != 0);
-    _communicator->destroy();
-
-    {
-        Mutex::Lock lock(_mutex);
-        _callbackInProgress = false;
-    }
-    _condVar.signal();
-}
-
-void
-Ice::Application::shutdownOnInterruptCallback(int signal)
-{
-    {
-        Mutex::Lock lock(_mutex);
-        if(_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        if(_nohup && signal == static_cast<int>(SIGHUP))
-        {
-            return;
-        }
-
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
-    }
-
-    assert(_communicator != 0);
-    _communicator->shutdown();
-
-    {
-        Mutex::Lock lock(_mutex);
-        _callbackInProgress = false;
-    }
-    _condVar.signal();
-}
-
-void
-Ice::Application::callbackOnInterruptCallback(int signal)
-{
-    {
-        Mutex::Lock lock(_mutex);
-        if(_destroyed)
-        {
-            //
-            // Being destroyed by main thread
-            //
-            return;
-        }
-        // For SIGHUP the user callback is always called. It can
-        // decide what to do.
-        assert(!_callbackInProgress);
-        _callbackInProgress = true;
-        _interrupted = true;
-    }
-
-    try
-    {
-        assert(_application != 0);
-        _application->interruptCallback(signal);
-    }
-    catch(const Ice::Exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): Ice::Exception: " << ex;
-    }
-    catch(const std::exception& ex)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): std::exception: " << ex;
-    }
-    catch(const std::string& msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): " << msg;
-    }
-    catch(const char* msg)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): " << msg;
-    }
-    catch(...)
-    {
-        Error out(getProcessLogger());
-        out << "(while interrupting in response to signal " << signal << "): unknown exception";
-    }
-
-    {
-        Mutex::Lock lock(_mutex);
-        _callbackInProgress = false;
-    }
-    _condVar.signal();
-}

data/dist/ice/cpp/src/Ice/AsyncResult.cpp

@@ -1,70 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <Ice/AsyncResult.h>
-#include <Ice/Proxy.h>
-
-using namespace std;
-using namespace Ice;
-
-IceUtil::Shared* Ice::upCast(AsyncResult* p) { return p; }
-
-AsyncResult::~AsyncResult()
-{
-    // Out of line to avoid weak vtable
-}
-
-void
-AsyncResult::_check(const AsyncResultPtr& r, const IceProxy::Ice::Object* prx, const string& operation)
-{
-    check(r, operation);
-    if(r->getProxy().get() != prx)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Proxy for call to end_" + operation +
-                                                " does not match proxy that was used to call corresponding begin_" +
-                                                operation + " method");
-    }
-}
-
-void
-AsyncResult::_check(const AsyncResultPtr& r, const Ice::Communicator* com, const string& operation)
-{
-    check(r, operation);
-    if(r->getCommunicator().get() != com)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Communicator for call to end_" + operation +
-                                                " does not match communicator that was used to call corresponding " +
-                                                "begin_" + operation + " method");
-    }
-}
-
-void
-AsyncResult::_check(const AsyncResultPtr& r, const Ice::Connection* con, const string& operation)
-{
-    check(r, operation);
-    if(r->getConnection().get() != con)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Connection for call to end_" + operation +
-                                                " does not match connection that was used to call corresponding " +
-                                                "begin_" + operation + " method");
-    }
-}
-
-void
-AsyncResult::check(const AsyncResultPtr& r, const string& operation)
-{
-    if(!r)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "AsyncResult == null");
-    }
-    else if(r->getOperation() != operation)
-    {
-        throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, "Incorrect operation for end_" + operation +
-                                                " method: " + r->getOperation());
-    }
-}
-
-#endif