zeroc-ice 3.7.9.1 → 3.8.0

data/ext/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/ext/ice/cpp/src/Ice/RequestHandler.cpp

@@ -1,37 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/RequestHandler.h>
-#include <Ice/Reference.h>
-
-using namespace std;
-using namespace IceInternal;
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(RequestHandler* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(CancellationHandler* p) { return p; }
-#endif
-
-RetryException::RetryException(const Ice::LocalException& ex)
-{
-    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.ice_clone());
-}
-
-RetryException::RetryException(const RetryException& ex)
-{
-    ICE_SET_EXCEPTION_FROM_CLONE(_ex, ex.get()->ice_clone());
-}
-
-const Ice::LocalException*
-RetryException::get() const
-{
-    assert(_ex.get());
-    return _ex.get();
-}
-
-RequestHandler::RequestHandler(const ReferencePtr& reference) :
-    _reference(reference),
-    _response(reference->getMode() == Reference::ModeTwoway)
-{
-}

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

@@ -1,78 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_REQUEST_HANDLER_H
-#define ICE_REQUEST_HANDLER_H
-
-#include <IceUtil/Shared.h>
-#include <Ice/UniquePtr.h>
-
-#include <Ice/RequestHandlerF.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/ProxyF.h>
-#include <Ice/ConnectionIF.h>
-
-namespace Ice
-{
-
-class LocalException;
-
-}
-
-namespace IceInternal
-{
-
-//
-// An exception wrapper, which is used to notify that the request
-// handler should be cleared and the invocation retried.
-//
-class RetryException
-{
-public:
-
-    RetryException(const Ice::LocalException&);
-    RetryException(const RetryException&);
-
-    const Ice::LocalException* get() const;
-
-private:
-
-    IceInternal::UniquePtr<Ice::LocalException> _ex;
-};
-
-class CancellationHandler
-#ifndef ICE_CPP11_MAPPING
-    : public virtual IceUtil::Shared
-#endif
-{
-public:
-
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&) = 0;
-};
-
-class RequestHandler : public CancellationHandler
-{
-public:
-
-    RequestHandler(const ReferencePtr&);
-
-    virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&) = 0;
-
-    virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
-
-    const ReferencePtr& getReference() const { return _reference; } // Inlined for performances.
-
-    virtual Ice::ConnectionIPtr getConnection() = 0;
-    virtual Ice::ConnectionIPtr waitForConnection() = 0;
-
-protected:
-
-    const ReferencePtr _reference;
-    const bool _response;
-};
-
-}
-
-#endif

data/ext/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/ext/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/ext/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/ext/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

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

@@ -1,157 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/RetryQueue.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/LocalException.h>
-#include <Ice/Instance.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/LoggerUtil.h>
-
-using namespace std;
-using namespace Ice;
-using namespace IceInternal;
-
-IceUtil::Shared* IceInternal::upCast(RetryQueue* p) { return p; }
-
-IceInternal::RetryTask::RetryTask(const InstancePtr& instance,
-                                  const RetryQueuePtr& queue,
-                                  const ProxyOutgoingAsyncBasePtr& outAsync) :
-    _instance(instance),
-    _queue(queue),
-    _outAsync(outAsync)
-{
-}
-
-void
-IceInternal::RetryTask::runTimerTask()
-{
-    _outAsync->retry(); // Retry again the invocation.
-
-    //
-    // NOTE: this must be called last, destroy() blocks until all task
-    // are removed to prevent the client thread pool to be destroyed
-    // (we still need the client thread pool at this point to call
-    // exception callbacks with CommunicatorDestroyedException).
-    //
-    _queue->remove(ICE_SHARED_FROM_THIS);
-}
-
-void
-IceInternal::RetryTask::asyncRequestCanceled(const OutgoingAsyncBasePtr& /*outAsync*/, const Ice::LocalException& ex)
-{
-    if(_queue->cancel(ICE_SHARED_FROM_THIS))
-    {
-        if(_instance->traceLevels()->retry >= 1)
-        {
-            Trace out(_instance->initializationData().logger, _instance->traceLevels()->retryCat);
-            out << "operation retry canceled\n" << ex;
-        }
-        if(_outAsync->exception(ex))
-        {
-            _outAsync->invokeExceptionAsync();
-        }
-    }
-}
-
-void
-IceInternal::RetryTask::destroy()
-{
-    try
-    {
-        _outAsync->abort(CommunicatorDestroyedException(__FILE__, __LINE__));
-    }
-    catch(const CommunicatorDestroyedException&)
-    {
-        // Abort can throw if there's no callback, ignore.
-    }
-}
-
-bool
-IceInternal::RetryTask::operator<(const RetryTask& rhs) const
-{
-    return this < &rhs;
-}
-
-IceInternal::RetryQueue::RetryQueue(const InstancePtr& instance) : _instance(instance)
-{
-}
-
-void
-IceInternal::RetryQueue::add(const ProxyOutgoingAsyncBasePtr& out, int interval)
-{
-    Lock sync(*this);
-    if(!_instance)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-    RetryTaskPtr task = ICE_MAKE_SHARED(RetryTask, _instance, this, out);
-    out->cancelable(task); // This will throw if the request is canceled.
-    try
-    {
-        _instance->timer()->schedule(task, IceUtil::Time::milliSeconds(interval));
-    }
-    catch(const IceUtil::IllegalArgumentException&) // Expected if the communicator destroyed the timer.
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-    _requests.insert(task);
-}
-
-void
-IceInternal::RetryQueue::destroy()
-{
-    Lock sync(*this);
-    assert(_instance);
-
-    set<RetryTaskPtr>::iterator p = _requests.begin();
-    while(p != _requests.end())
-    {
-        if(_instance->timer()->cancel(*p))
-        {
-            (*p)->destroy();
-            _requests.erase(p++);
-        }
-        else
-        {
-            ++p;
-        }
-    }
-
-    _instance = 0;
-    while(!_requests.empty())
-    {
-        wait();
-    }
-}
-
-void
-IceInternal::RetryQueue::remove(const RetryTaskPtr& task)
-{
-    Lock sync(*this);
-    assert(_requests.find(task) != _requests.end());
-    _requests.erase(task);
-    if(!_instance && _requests.empty())
-    {
-        notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
-    }
-}
-
-bool
-IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
-{
-    Lock sync(*this);
-    if(_requests.erase(task) > 0)
-    {
-        if(_instance)
-        {
-            return _instance->timer()->cancel(task);
-        }
-        else if(_requests.empty())
-        {
-            notify(); // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
-        }
-    }
-    return false;
-}

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

@@ -1,66 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_RETRY_QUEUE_H
-#define ICE_RETRY_QUEUE_H
-
-#include <IceUtil/Shared.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/Timer.h>
-#include <Ice/RetryQueueF.h>
-#include <Ice/OutgoingAsyncF.h>
-#include <Ice/InstanceF.h>
-#include <Ice/RequestHandler.h> // For CancellationHandler
-
-namespace IceInternal
-{
-
-class RetryTask : public IceUtil::TimerTask,
-                  public CancellationHandler
-#ifdef ICE_CPP11_MAPPING
-                , public std::enable_shared_from_this<RetryTask>
-#endif
-{
-public:
-
-    RetryTask(const InstancePtr&, const RetryQueuePtr&, const ProxyOutgoingAsyncBasePtr&);
-
-    virtual void runTimerTask();
-
-    virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
-
-    void destroy();
-
-    bool operator<(const RetryTask&) const;
-
-private:
-
-    const InstancePtr _instance;
-    const RetryQueuePtr _queue;
-    const ProxyOutgoingAsyncBasePtr _outAsync;
-};
-ICE_DEFINE_PTR(RetryTaskPtr, RetryTask);
-
-class RetryQueue : public IceUtil::Shared, public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
-
-    RetryQueue(const InstancePtr&);
-
-    void add(const ProxyOutgoingAsyncBasePtr&, int);
-    void destroy();
-
-private:
-
-    void remove(const RetryTaskPtr&);
-    bool cancel(const RetryTaskPtr&);
-    friend class RetryTask;
-
-    InstancePtr _instance;
-    std::set<RetryTaskPtr> _requests;
-};
-
-}
-
-#endif

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

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