zeroc-ice 3.7.9.1 → 3.8.0

data/ext/ice/cpp/src/Ice/ConnectRequestHandler.cpp

@@ -1,348 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/ConnectRequestHandler.h>
-#include <Ice/ConnectionRequestHandler.h>
-#include <Ice/RequestHandlerFactory.h>
-#include <Ice/Instance.h>
-#include <Ice/Proxy.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/Protocol.h>
-#include <Ice/Properties.h>
-#include <Ice/ThreadPool.h>
-
-using namespace std;
-using namespace IceInternal;
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(ConnectRequestHandler* p) { return p; }
-#endif
-
-ConnectRequestHandler::ConnectRequestHandler(const ReferencePtr& ref, const Ice::ObjectPrxPtr& proxy) :
-    RequestHandler(ref),
-    _proxy(proxy),
-    _initialized(false),
-    _flushing(false)
-{
-}
-
-RequestHandlerPtr
-ConnectRequestHandler::connect(const Ice::ObjectPrxPtr& proxy)
-{
-    Lock sync(*this);
-    if(!initialized())
-    {
-        _proxies.insert(proxy);
-    }
-    return _requestHandler ? _requestHandler : ICE_SHARED_FROM_THIS;
-}
-
-RequestHandlerPtr
-ConnectRequestHandler::update(const RequestHandlerPtr& previousHandler, const RequestHandlerPtr& newHandler)
-{
-    return previousHandler.get() == this ? newHandler : ICE_SHARED_FROM_THIS;
-}
-
-AsyncStatus
-ConnectRequestHandler::sendAsyncRequest(const ProxyOutgoingAsyncBasePtr& out)
-{
-    {
-        Lock sync(*this);
-        if(!_initialized)
-        {
-            out->cancelable(ICE_SHARED_FROM_THIS); // This will throw if the request is canceled
-        }
-
-        if(!initialized())
-        {
-            _requests.push_back(out);
-            return AsyncStatusQueued;
-        }
-    }
-    return out->invokeRemote(_connection, _compress, _response);
-}
-
-void
-ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync, const Ice::LocalException& ex)
-{
-    {
-        Lock sync(*this);
-        if(_exception)
-        {
-            return; // The request has been notified of a failure already.
-        }
-
-        if(!initialized())
-        {
-            for(deque<ProxyOutgoingAsyncBasePtr>::iterator p = _requests.begin(); p != _requests.end(); ++p)
-            {
-                if(p->get() == outAsync.get())
-                {
-                    _requests.erase(p);
-                    if(outAsync->exception(ex))
-                    {
-                        outAsync->invokeExceptionAsync();
-                    }
-                    return;
-                }
-            }
-        }
-    }
-    _connection->asyncRequestCanceled(outAsync, ex);
-}
-
-Ice::ConnectionIPtr
-ConnectRequestHandler::getConnection()
-{
-    Lock sync(*this);
-    //
-    // First check for the connection, it's important otherwise the user could first get a connection
-    // and then the exception if he tries to obtain the proxy cached connection mutiple times (the
-    // exception can be set after the connection is set if the flush of pending requests fails).
-    //
-    if(_connection)
-    {
-        return _connection;
-    }
-    else if(_exception)
-    {
-        _exception->ice_throw();
-    }
-    return ICE_NULLPTR;
-}
-
-Ice::ConnectionIPtr
-ConnectRequestHandler::waitForConnection()
-{
-    Lock sync(*this);
-    if(_exception)
-    {
-        throw RetryException(*_exception);
-    }
-    //
-    // Wait for the connection establishment to complete or fail.
-    //
-    while(!_initialized && !_exception)
-    {
-        wait();
-    }
-
-    if(_exception)
-    {
-        _exception->ice_throw();
-        return 0; // Keep the compiler happy.
-    }
-    else
-    {
-        return _connection;
-    }
-}
-
-void
-ConnectRequestHandler::setConnection(const Ice::ConnectionIPtr& connection, bool compress)
-{
-    {
-        Lock sync(*this);
-        assert(!_flushing && !_exception && !_connection);
-        _connection = connection;
-        _compress = compress;
-    }
-
-    //
-    // If this proxy is for a non-local object, and we are using a router, then
-    // add this proxy to the router info object.
-    //
-    RouterInfoPtr ri = _reference->getRouterInfo();
-    if(ri && !ri->addProxy(_proxy, ICE_SHARED_FROM_THIS))
-    {
-        return; // The request handler will be initialized once addProxy returns.
-    }
-
-    //
-    // We can now send the queued requests.
-    //
-    flushRequests();
-}
-
-void
-ConnectRequestHandler::setException(const Ice::LocalException& ex)
-{
-    {
-        Lock sync(*this);
-        assert(!_flushing && !_initialized && !_exception);
-        _flushing = true; // Ensures request handler is removed before processing new requests.
-        ICE_SET_EXCEPTION_FROM_CLONE(_exception, ex.ice_clone());
-    }
-
-    //
-    // NOTE: remove the request handler *before* notifying the requests that the connection
-    // failed. It's important to ensure that future invocations will obtain a new connect
-    // request handler once invocations are notified.
-    //
-    try
-    {
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-    }
-    catch(const Ice::CommunicatorDestroyedException&)
-    {
-        // Ignore
-    }
-
-    for(deque<ProxyOutgoingAsyncBasePtr>::const_iterator p = _requests.begin(); p != _requests.end(); ++p)
-    {
-        if((*p)->exception(ex))
-        {
-            (*p)->invokeExceptionAsync();
-        }
-    }
-    _requests.clear();
-
-    {
-        Lock sync(*this);
-        _flushing = false;
-        _proxies.clear();
-        _proxy = 0; // Break cyclic reference count.
-        notifyAll();
-    }
-}
-
-void
-ConnectRequestHandler::addedProxy()
-{
-    //
-    // The proxy was added to the router info, we're now ready to send the
-    // queued requests.
-    //
-    flushRequests();
-}
-
-bool
-ConnectRequestHandler::initialized()
-{
-    // Must be called with the mutex locked.
-
-    if(_initialized)
-    {
-        assert(_connection);
-        return true;
-    }
-    else
-    {
-        while(_flushing)
-        {
-            wait();
-        }
-
-        if(_exception)
-        {
-            if(_connection)
-            {
-                //
-                // Only throw if the connection didn't get established. If
-                // it died after being established, we allow the caller to
-                // retry the connection establishment by not throwing here
-                // (the connection will throw RetryException).
-                //
-                return true;
-            }
-            _exception->ice_throw();
-            return false; // Keep the compiler happy.
-        }
-        else
-        {
-            return _initialized;
-        }
-    }
-}
-
-void
-ConnectRequestHandler::flushRequests()
-{
-    {
-        Lock sync(*this);
-        assert(_connection && !_initialized);
-
-        //
-        // We set the _flushing flag to true to prevent any additional queuing. Callers
-        // might block for a little while as the queued requests are being sent but this
-        // shouldn't be an issue as the request sends are non-blocking.
-        //
-        _flushing = true;
-    }
-
-#ifdef ICE_CPP11_MAPPING
-    std::unique_ptr<Ice::LocalException> exception;
-#else
-    IceInternal::UniquePtr<Ice::LocalException> exception;
-#endif
-    while(!_requests.empty()) // _requests is immutable when _flushing = true
-    {
-        ProxyOutgoingAsyncBasePtr& req = _requests.front();
-        try
-        {
-            if(req->invokeRemote(_connection, _compress, _response) & AsyncStatusInvokeSentCallback)
-            {
-                req->invokeSentAsync();
-            }
-        }
-        catch(const RetryException& ex)
-        {
-            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.get()->ice_clone());
-
-            // Remove the request handler before retrying.
-            _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-
-            req->retryException(*exception);
-        }
-        catch(const Ice::LocalException& ex)
-        {
-            ICE_SET_EXCEPTION_FROM_CLONE(exception, ex.ice_clone());
-
-            if(req->exception(ex))
-            {
-                req->invokeExceptionAsync();
-            }
-        }
-        _requests.pop_front();
-    }
-
-    //
-    // If we aren't caching the connection, don't bother creating a
-    // connection request handler. Otherwise, update the proxies
-    // request handler to use the more efficient connection request
-    // handler.
-    //
-    if(_reference->getCacheConnection() && !exception)
-    {
-        _requestHandler = ICE_MAKE_SHARED(ConnectionRequestHandler, _reference, _connection, _compress);
-        for(set<Ice::ObjectPrxPtr>::const_iterator p = _proxies.begin(); p != _proxies.end(); ++p)
-        {
-            (*p)->_updateRequestHandler(ICE_SHARED_FROM_THIS, _requestHandler);
-        }
-    }
-
-    {
-        Lock sync(*this);
-        assert(!_initialized);
-#ifdef ICE_CPP11_MAPPING
-        swap(_exception, exception);
-#else
-        _exception.swap(exception);
-#endif
-        _initialized = !_exception;
-        _flushing = false;
-
-        //
-        // Only remove once all the requests are flushed to
-        // guarantee serialization.
-        //
-        _reference->getInstance()->requestHandlerFactory()->removeRequestHandler(_reference, ICE_SHARED_FROM_THIS);
-
-        _proxies.clear();
-        _proxy = ICE_NULLPTR; // Break cyclic reference count.
-        notifyAll();
-    }
-}

data/ext/ice/cpp/src/Ice/ConnectRequestHandler.h

@@ -1,72 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CONNECT_REQUEST_HANDLER_H
-#define ICE_CONNECT_REQUEST_HANDLER_H
-
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Mutex.h>
-#include <Ice/UniquePtr.h>
-
-#include <Ice/ConnectRequestHandlerF.h>
-#include <Ice/RequestHandler.h>
-#include <Ice/Reference.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/ProxyF.h>
-
-#include <deque>
-#include <set>
-
-namespace IceInternal
-{
-
-class ConnectRequestHandler ICE_FINAL : public RequestHandler,
-                                        public Reference::GetConnectionCallback,
-                                        public RouterInfo::AddProxyCallback,
-                                        public IceUtil::Monitor<IceUtil::Mutex>
-#ifdef ICE_CPP11_MAPPING
-                            , public std::enable_shared_from_this<ConnectRequestHandler>
-#endif
-{
-public:
-
-    ConnectRequestHandler(const ReferencePtr&, const Ice::ObjectPrxPtr&);
-
-    RequestHandlerPtr connect(const Ice::ObjectPrxPtr&);
-    virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&);
-
-    virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&);
-
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
-
-    virtual Ice::ConnectionIPtr getConnection();
-    virtual Ice::ConnectionIPtr waitForConnection();
-
-    virtual void setConnection(const Ice::ConnectionIPtr&, bool);
-    virtual void setException(const Ice::LocalException&);
-
-    virtual void addedProxy();
-
-private:
-
-    bool initialized();
-    void flushRequests();
-
-    Ice::ObjectPrxPtr _proxy;
-    std::set<Ice::ObjectPrxPtr> _proxies;
-
-    Ice::ConnectionIPtr _connection;
-    bool _compress;
-    IceInternal::UniquePtr<Ice::LocalException> _exception;
-    bool _initialized;
-    bool _flushing;
-
-    std::deque<ProxyOutgoingAsyncBasePtr> _requests;
-
-    RequestHandlerPtr _requestHandler;
-};
-
-}
-
-#endif

data/ext/ice/cpp/src/Ice/ConnectRequestHandlerF.h

@@ -1,24 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CONNECT_REQUEST_HANDLER_F_H
-#define ICE_CONNECT_REQUEST_HANDLER_F_H
-
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
-
-namespace IceInternal
-{
-
-class ConnectRequestHandler;
-#ifdef ICE_CPP11_MAPPING
-using ConnectRequestHandlerPtr = ::std::shared_ptr<ConnectRequestHandler>;
-#else
-IceUtil::Shared* upCast(ConnectRequestHandler*);
-typedef IceInternal::Handle<ConnectRequestHandler> ConnectRequestHandlerPtr;
-#endif
-
-}
-
-#endif

data/ext/ice/cpp/src/Ice/Connection.cpp

@@ -1,155 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.9
-//
-// <auto-generated>
-//
-// Generated from file `Connection.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
-
-#ifndef ICE_API_EXPORTS
-#   define ICE_API_EXPORTS
-#endif
-#include <Ice/Connection.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <Ice/InputStream.h>
-#include <Ice/OutputStream.h>
-#include <IceUtil/PopDisableWarnings.h>
-
-#if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
-#elif defined(__clang__)
-#   pragma clang diagnostic ignored "-Wshadow"
-#elif defined(__GNUC__)
-#   pragma GCC diagnostic ignored "-Wshadow"
-#endif
-
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
-#       error Ice version mismatch!
-#   endif
-#   if ICE_INT_VERSION % 100 >= 50
-#       error Beta header file detected
-#   endif
-#   if ICE_INT_VERSION % 100 < 9
-#       error Ice patch level mismatch!
-#   endif
-#endif
-
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-namespace
-{
-
-}
-
-Ice::ConnectionInfo::~ConnectionInfo()
-{
-}
-
-Ice::Connection::~Connection()
-{
-}
-
-Ice::IPConnectionInfo::~IPConnectionInfo()
-{
-}
-
-Ice::TCPConnectionInfo::~TCPConnectionInfo()
-{
-}
-
-Ice::UDPConnectionInfo::~UDPConnectionInfo()
-{
-}
-
-Ice::WSConnectionInfo::~WSConnectionInfo()
-{
-}
-
-namespace Ice
-{
-}
-
-#else // C++98 mapping
-
-namespace
-{
-
-}
-
-Ice::ConnectionInfo::~ConnectionInfo()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(ConnectionInfo* p) { return p; }
-/// \endcond
-
-Ice::CloseCallback::~CloseCallback()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(CloseCallback* p) { return p; }
-/// \endcond
-
-Ice::HeartbeatCallback::~HeartbeatCallback()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(HeartbeatCallback* p) { return p; }
-/// \endcond
-
-Ice::Connection::~Connection()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(Connection* p) { return p; }
-/// \endcond
-
-Ice::IPConnectionInfo::~IPConnectionInfo()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(IPConnectionInfo* p) { return p; }
-/// \endcond
-
-Ice::TCPConnectionInfo::~TCPConnectionInfo()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(TCPConnectionInfo* p) { return p; }
-/// \endcond
-
-Ice::UDPConnectionInfo::~UDPConnectionInfo()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(UDPConnectionInfo* p) { return p; }
-/// \endcond
-
-Ice::WSConnectionInfo::~WSConnectionInfo()
-{
-}
-
-/// \cond INTERNAL
-ICE_API ::Ice::LocalObject* Ice::upCast(WSConnectionInfo* p) { return p; }
-/// \endcond
-
-namespace Ice
-{
-}
-
-#endif

data/ext/ice/cpp/src/Ice/ConnectionF.cpp

@@ -1,61 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-//
-// Ice version 3.7.9
-//
-// <auto-generated>
-//
-// Generated from file `ConnectionF.ice'
-//
-// Warning: do not edit this file.
-//
-// </auto-generated>
-//
-
-#ifndef ICE_API_EXPORTS
-#   define ICE_API_EXPORTS
-#endif
-#include <Ice/ConnectionF.h>
-#include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/PopDisableWarnings.h>
-
-#if defined(_MSC_VER)
-#   pragma warning(disable:4458) // declaration of ... hides class member
-#elif defined(__clang__)
-#   pragma clang diagnostic ignored "-Wshadow"
-#elif defined(__GNUC__)
-#   pragma GCC diagnostic ignored "-Wshadow"
-#endif
-
-#ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 307
-#       error Ice version mismatch!
-#   endif
-#   if ICE_INT_VERSION % 100 >= 50
-#       error Beta header file detected
-#   endif
-#   if ICE_INT_VERSION % 100 < 9
-#       error Ice patch level mismatch!
-#   endif
-#endif
-
-#ifdef ICE_CPP11_MAPPING // C++11 mapping
-
-namespace
-{
-
-}
-
-#else // C++98 mapping
-
-namespace
-{
-
-}
-
-namespace Ice
-{
-}
-
-#endif