zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/PropertiesI.h

@@ -1,70 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROPERTIES_I_H
-#define ICE_PROPERTIES_I_H
-
-#include <IceUtil/Mutex.h>
-#include <Ice/Properties.h>
-#include <Ice/StringConverter.h>
-
-#include <set>
-
-namespace Ice
-{
-
-class PropertiesI : public Properties, public IceUtil::Mutex
-{
-public:
-
-    virtual std::string getProperty(const std::string&) ICE_NOEXCEPT;
-    virtual std::string getPropertyWithDefault(const std::string&, const std::string&) ICE_NOEXCEPT;
-    virtual Ice::Int getPropertyAsInt(const std::string&) ICE_NOEXCEPT;
-    virtual Ice::Int getPropertyAsIntWithDefault(const std::string&, Ice::Int) ICE_NOEXCEPT;
-    virtual Ice::StringSeq getPropertyAsList(const std::string&) ICE_NOEXCEPT;
-    virtual Ice::StringSeq getPropertyAsListWithDefault(const std::string&, const Ice::StringSeq&) ICE_NOEXCEPT;
-
-    virtual PropertyDict getPropertiesForPrefix(const std::string&) ICE_NOEXCEPT;
-    virtual void setProperty(const std::string&, const std::string&);
-    virtual StringSeq getCommandLineOptions() ICE_NOEXCEPT;
-    virtual StringSeq parseCommandLineOptions(const std::string&, const StringSeq&);
-    virtual StringSeq parseIceCommandLineOptions(const StringSeq&);
-    virtual void load(const std::string&);
-    virtual PropertiesPtr clone() ICE_NOEXCEPT;
-
-    std::set<std::string> getUnusedProperties();
-
-    PropertiesI(const PropertiesI*);
-
-    PropertiesI();
-    PropertiesI(StringSeq&, const PropertiesPtr&);
-
-private:
-
-    void parseLine(const std::string&, const StringConverterPtr&);
-
-    void loadConfig();
-
-    struct PropertyValue
-    {
-        PropertyValue() :
-            used(false)
-        {
-        }
-
-        PropertyValue(const std::string& v, bool u) :
-            value(v),
-            used(u)
-        {
-        }
-
-        std::string value;
-        bool used;
-    };
-    std::map<std::string, PropertyValue> _properties;
-};
-
-}
-
-#endif

data/dist/ice/cpp/src/Ice/ProtocolPluginFacadeF.h

@@ -1,21 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROTOCOL_PLUGIN_FACADE_F_H
-#define ICE_PROTOCOL_PLUGIN_FACADE_F_H
-
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
-
-namespace IceInternal
-{
-
-class ProtocolPluginFacade;
-ICE_API IceUtil::Shared* upCast(ProtocolPluginFacade*);
-typedef Handle<ProtocolPluginFacade> ProtocolPluginFacadePtr;
-
-}
-
-#endif

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

@@ -1,300 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/Thread.h>
-#include <IceUtil/Time.h>
-#include <Ice/ProxyFactory.h>
-#include <Ice/Instance.h>
-#include <Ice/Proxy.h>
-#include <Ice/ReferenceFactory.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/Properties.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/LocalException.h>
-#include <Ice/OutgoingAsync.h>
-
-using namespace std;
-using namespace Ice;
-using namespace IceInternal;
-
-IceUtil::Shared* IceInternal::upCast(ProxyFactory* p) { return p; }
-
-ObjectPrxPtr
-IceInternal::ProxyFactory::stringToProxy(const string& str) const
-{
-    ReferencePtr ref = _instance->referenceFactory()->create(str, "");
-    return referenceToProxy(ref);
-}
-
-string
-IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const
-{
-    if(proxy)
-    {
-        return proxy->_getReference()->toString();
-    }
-    else
-    {
-        return "";
-    }
-}
-
-ObjectPrxPtr
-IceInternal::ProxyFactory::propertyToProxy(const string& prefix) const
-{
-    string proxy = _instance->initializationData().properties->getProperty(prefix);
-    ReferencePtr ref = _instance->referenceFactory()->create(proxy, prefix);
-    return referenceToProxy(ref);
-}
-
-PropertyDict
-IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const string& prefix) const
-{
-    if(proxy)
-    {
-        return proxy->_getReference()->toProperty(prefix);
-    }
-    else
-    {
-        return PropertyDict();
-    }
-}
-
-ObjectPrxPtr
-IceInternal::ProxyFactory::streamToProxy(InputStream* s) const
-{
-    Identity ident;
-    s->read(ident);
-
-    ReferencePtr ref = _instance->referenceFactory()->create(ident, s);
-    return referenceToProxy(ref);
-}
-
-ObjectPrxPtr
-IceInternal::ProxyFactory::referenceToProxy(const ReferencePtr& ref) const
-{
-    if(ref)
-    {
-#ifdef ICE_CPP11_MAPPING
-        auto proxy = createProxy<ObjectPrx>();
-#else
-        ObjectPrx proxy = new ::IceProxy::Ice::Object();
-#endif
-        proxy->setup(ref);
-        return proxy;
-    }
-    else
-    {
-        return ICE_NULLPTR;
-    }
-}
-
-int
-IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, const ReferencePtr& ref, int& cnt) const
-{
-    TraceLevelsPtr traceLevels = _instance->traceLevels();
-    LoggerPtr logger = _instance->initializationData().logger;
-
-    //
-    // We don't retry batch requests because the exception might have
-    // caused all the requests batched with the connection to be
-    // aborted and we want the application to be notified.
-    //
-    if(ref->getMode() == Reference::ModeBatchOneway || ref->getMode() == Reference::ModeBatchDatagram)
-    {
-        ex.ice_throw();
-    }
-
-    //
-    // If it's a fixed proxy, retrying isn't useful as the proxy is tied to
-    // the connection and the request will fail with the exception.
-    //
-    if(dynamic_cast<const FixedReference*>(ref.get()))
-    {
-        ex.ice_throw();
-    }
-
-    const ObjectNotExistException* one = dynamic_cast<const ObjectNotExistException*>(&ex);
-    if(one)
-    {
-        if(ref->getRouterInfo() && one->operation == "ice_add_proxy")
-        {
-            //
-            // If we have a router, an ObjectNotExistException with an
-            // operation name "ice_add_proxy" indicates to the client
-            // that the router isn't aware of the proxy (for example,
-            // because it was evicted by the router). In this case, we
-            // must *always* retry, so that the missing proxy is added
-            // to the router.
-            //
-
-            ref->getRouterInfo()->clearCache(ref);
-
-            if(traceLevels->retry >= 1)
-            {
-                Trace out(logger, traceLevels->retryCat);
-                out << "retrying operation call to add proxy to router\n" << ex;
-            }
-
-            return 0; // We must always retry, so we don't look at the retry count.
-        }
-        else if(ref->isIndirect())
-        {
-            //
-            // We retry ObjectNotExistException if the reference is
-            // indirect.
-            //
-
-            if(ref->isWellKnown())
-            {
-                LocatorInfoPtr li = ref->getLocatorInfo();
-                if(li)
-                {
-                    li->clearCache(ref);
-                }
-            }
-        }
-        else
-        {
-            //
-            // For all other cases, we don't retry
-            // ObjectNotExistException.
-            //
-            ex.ice_throw();
-        }
-    }
-    else if(dynamic_cast<const RequestFailedException*>(&ex))
-    {
-        //
-        // We don't retry other *NotExistException, which are all
-        // derived from RequestFailedException.
-        //
-        ex.ice_throw();
-    }
-
-    //
-    // There is no point in retrying an operation that resulted in a
-    // MarshalException. This must have been raised locally (because
-    // if it happened in a server it would result in an
-    // UnknownLocalException instead), which means there was a problem
-    // in this process that will not change if we try again.
-    //
-    // The most likely cause for a MarshalException is exceeding the
-    // maximum message size, which is represented by the subclass
-    // MemoryLimitException. For example, a client can attempt to send
-    // a message that exceeds the maximum memory size, or accumulate
-    // enough batch requests without flushing that the maximum size is
-    // reached.
-    //
-    // This latter case is especially problematic, because if we were
-    // to retry a batch request after a MarshalException, we would in
-    // fact silently discard the accumulated requests and allow new
-    // batch requests to accumulate. If the subsequent batched
-    // requests do not exceed the maximum message size, it appears to
-    // the client that all of the batched requests were accepted, when
-    // in reality only the last few are actually sent.
-    //
-    if(dynamic_cast<const MarshalException*>(&ex))
-    {
-        ex.ice_throw();
-    }
-
-    //
-    // Don't retry if the communicator is destroyed, object adapter is deactivated,
-    // or connection is manually closed.
-    //
-    if(dynamic_cast<const CommunicatorDestroyedException*>(&ex) ||
-       dynamic_cast<const ObjectAdapterDeactivatedException*>(&ex) ||
-       dynamic_cast<const ConnectionManuallyClosedException*>(&ex))
-    {
-        ex.ice_throw();
-    }
-
-    //
-    // Don't retry invocation timeouts.
-    //
-    if(dynamic_cast<const InvocationTimeoutException*>(&ex) || dynamic_cast<const InvocationCanceledException*>(&ex))
-    {
-        ex.ice_throw();
-    }
-
-    ++cnt;
-    assert(cnt > 0);
-
-    int interval = -1;
-    if(cnt == static_cast<int>(_retryIntervals.size() + 1) && dynamic_cast<const CloseConnectionException*>(&ex))
-    {
-        //
-        // A close connection exception is always retried at least once, even if the retry
-        // limit is reached.
-        //
-        interval = 0;
-    }
-    else if(cnt > static_cast<int>(_retryIntervals.size()))
-    {
-        if(traceLevels->retry >= 1)
-        {
-            Trace out(logger, traceLevels->retryCat);
-            out << "cannot retry operation call because retry limit has been exceeded\n" << ex;
-        }
-        ex.ice_throw();
-    }
-    else
-    {
-        interval = _retryIntervals[static_cast<size_t>(cnt - 1)];
-    }
-
-    if(traceLevels->retry >= 1)
-    {
-        Trace out(logger, traceLevels->retryCat);
-        out << "retrying operation call";
-        if(interval > 0)
-        {
-            out << " in " << interval << "ms";
-        }
-        out << " because of exception\n" << ex;
-    }
-    return interval;
-}
-
-IceInternal::ProxyFactory::ProxyFactory(const InstancePtr& instance) :
-    _instance(instance)
-{
-    StringSeq retryValues = _instance->initializationData().properties->getPropertyAsList("Ice.RetryIntervals");
-    if(retryValues.size() == 0)
-    {
-        _retryIntervals.push_back(0);
-    }
-    else
-    {
-        for(StringSeq::const_iterator p = retryValues.begin(); p != retryValues.end(); ++p)
-        {
-            istringstream value(*p);
-
-            int v;
-            if(!(value >> v) || !value.eof())
-            {
-                v = 0;
-            }
-
-            //
-            // If -1 is the first value, no retry and wait intervals.
-            //
-            if(v == -1 && _retryIntervals.empty())
-            {
-                break;
-            }
-
-            _retryIntervals.push_back(v > 0 ? v : 0);
-        }
-    }
-}
-
-IceInternal::ProxyFactory::~ProxyFactory()
-{
-}

data/dist/ice/cpp/src/Ice/ProxyFactory.h

@@ -1,57 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_PROXY_FACTORY_H
-#define ICE_PROXY_FACTORY_H
-
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <Ice/ProxyFactoryF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/Exception.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/Properties.h>
-
-namespace Ice
-{
-
-class OutputStream;
-class InputStream;
-
-}
-
-namespace IceInternal
-{
-
-class ProxyFactory : public IceUtil::Shared
-{
-public:
-
-    Ice::ObjectPrxPtr stringToProxy(const std::string&) const;
-    std::string proxyToString(const Ice::ObjectPrxPtr&) const;
-
-    Ice::ObjectPrxPtr propertyToProxy(const std::string&) const;
-    Ice::PropertyDict proxyToProperty(const Ice::ObjectPrxPtr&, const std::string&) const;
-
-    Ice::ObjectPrxPtr streamToProxy(Ice::InputStream*) const;
-
-    Ice::ObjectPrxPtr referenceToProxy(const ReferencePtr&) const;
-
-    int checkRetryAfterException(const Ice::LocalException&, const ReferencePtr&, int&) const;
-
-private:
-
-    ProxyFactory(const InstancePtr&);
-    virtual ~ProxyFactory();
-    friend class Instance;
-
-    InstancePtr _instance;
-    std::vector<int> _retryIntervals;
-};
-
-}
-
-#endif

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

@@ -1,38 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/RegisterPluginsInit.h>
-#include <Ice/CommunicatorF.h>
-#include <Ice/Initialize.h>
-
-extern "C"
-{
-
-Ice::Plugin* createStringConverter(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
-Ice::Plugin* createIceUDP(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
-Ice::Plugin* createIceTCP(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
-Ice::Plugin* createIceWS(const Ice::CommunicatorPtr&, const std::string&, const Ice::StringSeq&);
-
-}
-
-IceInternal::RegisterPluginsInit::RegisterPluginsInit()
-{
-    Ice::registerPluginFactory("IceTCP", createIceTCP, true);
-
-    //
-    // Only include the UDP and WS transport plugins with non-static builds or Gem/PyPI/Swift
-    // builds.
-    //
-#if !defined(ICE_STATIC_LIBS) || defined(ICE_GEM) || defined(ICE_PYPI) || defined(ICE_SWIFT)
-    Ice::registerPluginFactory("IceUDP", createIceUDP, true);
-    Ice::registerPluginFactory("IceWS", createIceWS, true);
-#endif
-
-    //
-    // Also include IceStringConverter in Gem/PyPI builds.
-    //
-#if defined(ICE_GEM) || defined(ICE_PYPI)
-    Ice::registerPluginFactory("IceStringConverter", createStringConverter, false);
-#endif
-}

data/dist/ice/cpp/src/Ice/RegisterPluginsInit.h

@@ -1,20 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_REGISTER_PLUGINS_INIT_H
-#define ICE_REGISTER_PLUGINS_INIT_H
-
-namespace IceInternal
-{
-
-class RegisterPluginsInit
-{
-public:
-
-    RegisterPluginsInit();
-};
-
-}
-
-#endif

data/dist/ice/cpp/src/Ice/ReplyStatus.h

@@ -1,24 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_REPLY_STATUS_H
-#define ICE_REPLY_STATUS_H
-
-#include <Ice/Config.h>
-
-namespace IceInternal
-{
-
-static const Ice::Byte replyOK = 0;
-static const Ice::Byte replyUserException = 1;
-static const Ice::Byte replyObjectNotExist = 2;
-static const Ice::Byte replyFacetNotExist = 3;
-static const Ice::Byte replyOperationNotExist = 4;
-static const Ice::Byte replyUnknownLocalException = 5;
-static const Ice::Byte replyUnknownUserException = 6;
-static const Ice::Byte replyUnknownException = 7;
-
-}
-
-#endif

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

@@ -1,77 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/RequestHandlerFactory.h>
-#include <Ice/CollocatedRequestHandler.h>
-#include <Ice/ConnectRequestHandler.h>
-#include <Ice/CollocatedRequestHandler.h>
-#include <Ice/Reference.h>
-#include <Ice/ObjectAdapterFactory.h>
-#include <Ice/Instance.h>
-
-using namespace std;
-using namespace IceInternal;
-
-RequestHandlerFactory::RequestHandlerFactory(const InstancePtr& instance) : _instance(instance)
-{
-}
-
-RequestHandlerPtr
-IceInternal::RequestHandlerFactory::getRequestHandler(const RoutableReferencePtr& ref, const Ice::ObjectPrxPtr& proxy)
-{
-    if(ref->getCollocationOptimized())
-    {
-        Ice::ObjectAdapterPtr adapter = _instance->objectAdapterFactory()->findObjectAdapter(proxy);
-        if(adapter)
-        {
-            return proxy->_setRequestHandler(ICE_MAKE_SHARED(CollocatedRequestHandler, ref, adapter));
-        }
-    }
-
-    ConnectRequestHandlerPtr handler;
-    bool connect = false;
-    if(ref->getCacheConnection())
-    {
-        Lock sync(*this);
-        map<ReferencePtr, ConnectRequestHandlerPtr>::iterator p = _handlers.find(ref);
-        if(p == _handlers.end())
-        {
-            handler = ICE_MAKE_SHARED(ConnectRequestHandler, ref, proxy);
-            _handlers.insert(make_pair(ref, handler));
-            connect = true;
-        }
-        else
-        {
-            handler = p->second;
-        }
-    }
-    else
-    {
-        handler = ICE_MAKE_SHARED(ConnectRequestHandler, ref, proxy);
-        connect = true;
-    }
-    if(connect)
-    {
-#ifdef ICE_CPP11_MAPPING
-        ref->getConnection(handler);
-#else
-        ref->getConnection(handler.get());
-#endif
-    }
-    return proxy->_setRequestHandler(handler->connect(proxy));
-}
-
-void
-IceInternal::RequestHandlerFactory::removeRequestHandler(const ReferencePtr& ref, const RequestHandlerPtr& handler)
-{
-    if(ref->getCacheConnection())
-    {
-        Lock sync(*this);
-        map<ReferencePtr, ConnectRequestHandlerPtr>::iterator p = _handlers.find(ref);
-        if(p != _handlers.end() && p->second.get() == handler.get())
-        {
-            _handlers.erase(p);
-        }
-    }
-}

data/dist/ice/cpp/src/Ice/RequestHandlerFactory.h

@@ -1,37 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_REQUEST_HANDLER_FACTORY_H
-#define ICE_REQUEST_HANDLER_FACTORY_H
-
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-
-#include <Ice/RequestHandlerF.h>
-#include <Ice/ConnectRequestHandlerF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/InstanceF.h>
-
-namespace IceInternal
-{
-
-class RequestHandlerFactory : public IceUtil::Shared, private IceUtil::Mutex
-{
-public:
-
-    RequestHandlerFactory(const InstancePtr&);
-
-    RequestHandlerPtr getRequestHandler(const RoutableReferencePtr&, const Ice::ObjectPrxPtr&);
-    void removeRequestHandler(const ReferencePtr&, const RequestHandlerPtr&);
-
-private:
-
-    const InstancePtr _instance;
-    std::map<ReferencePtr, ConnectRequestHandlerPtr> _handlers;
-};
-
-}
-
-#endif

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

@@ -1,12 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/ResponseHandler.h>
-
-using namespace std;
-using namespace IceInternal;
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(ResponseHandler* obj) { return obj; }
-#endif

data/dist/ice/cpp/src/Ice/ResponseHandler.h

@@ -1,43 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_RESPONSE_HANDLER_H
-#define ICE_RESPONSE_HANDLER_H
-
-#include <IceUtil/Shared.h>
-#include <IceUtil/Handle.h>
-
-#include <Ice/Config.h>
-#include <Ice/LocalException.h>
-#include <Ice/ResponseHandlerF.h>
-#include <Ice/VirtualShared.h>
-
-namespace Ice
-{
-
-class OutputStream;
-
-}
-
-namespace IceInternal
-{
-
-class ResponseHandler :
-#ifdef ICE_CPP11_MAPPING
-        public EnableSharedFromThis<ResponseHandler>
-#else
-        public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    virtual void sendResponse(Ice::Int, Ice::OutputStream*, Ice::Byte, bool) = 0;
-    virtual void sendNoResponse() = 0;
-    virtual bool systemException(Ice::Int, const Ice::SystemException&, bool) = 0;
-    virtual void invokeException(Ice::Int, const Ice::LocalException&, int, bool) = 0;
-};
-
-}
-
-#endif