zeroc-ice 3.6b1

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

@@ -0,0 +1,264 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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_OUTGOING_ASYNC_H
+#define ICE_OUTGOING_ASYNC_H
+
+#include <IceUtil/Timer.h>
+#include <Ice/OutgoingAsyncF.h>
+#include <Ice/AsyncResult.h>
+#include <Ice/CommunicatorF.h>
+#include <Ice/ConnectionIF.h>
+#include <Ice/ObjectAdapterF.h>
+
+namespace IceInternal
+{
+
+class RetryException;
+class CollocatedRequestHandler;
+
+//
+// Base class for handling asynchronous invocations. This class is
+// responsible for the handling of the output stream and the child
+// invocation observer.
+//
+class ICE_API OutgoingAsyncBase : public Ice::AsyncResult
+{
+public:
+
+    //
+    // Those methods must be overriden if the invocation is sent
+    // through a request handler.
+    //
+    virtual AsyncStatus send(const Ice::ConnectionIPtr&, bool, bool) { assert(false); return AsyncStatusQueued; }
+    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*) { assert(false); return AsyncStatusQueued; }
+
+    virtual bool sent();
+    virtual bool completed(const Ice::Exception&);
+    virtual void retryException(const Ice::Exception&);
+
+    // Those methods are public when called from an OutgoingAsyncBase reference.
+    using Ice::AsyncResult::cancelable;
+    using Ice::AsyncResult::invokeSent;
+    using Ice::AsyncResult::invokeSentAsync;
+    using Ice::AsyncResult::invokeCompleted;
+    using Ice::AsyncResult::invokeCompletedAsync;
+
+    void attachRemoteObserver(const Ice::ConnectionInfoPtr& c, const Ice::EndpointPtr& endpt, Ice::Int requestId)
+    {
+        const Ice::Int size = static_cast<Ice::Int>(_os.b.size() - headerSize - 4);
+        _childObserver.attach(getObserver().getRemoteObserver(c, endpt, requestId, size));
+    }
+    
+    void attachCollocatedObserver(const Ice::ObjectAdapterPtr& adapter, Ice::Int requestId)
+    {
+        const Ice::Int size = static_cast<Ice::Int>(_os.b.size() - headerSize - 4);
+        _childObserver.attach(getObserver().getCollocatedObserver(adapter, requestId, size));
+    }
+
+    BasicStream* getOs()
+    {
+        return &_os;
+    }
+
+protected:
+
+    OutgoingAsyncBase(const Ice::CommunicatorPtr&, const InstancePtr&, const std::string&, const CallbackBasePtr&, 
+                      const Ice::LocalObjectPtr&);
+
+    bool sent(bool);
+    bool finished(const Ice::Exception&);
+
+    ObserverHelperT<Ice::Instrumentation::ChildInvocationObserver> _childObserver;
+
+    BasicStream _os;
+};
+
+//
+// Base class for proxy based invocations. This class handles the
+// retry for proxy invocations. It also ensures the child observer is
+// correct notified of failures and make sure the retry task is
+// correctly canceled when the invocation completes.
+//
+class ICE_API ProxyOutgoingAsyncBase : public OutgoingAsyncBase, protected IceUtil::TimerTask
+{
+public:
+
+    virtual Ice::ObjectPrx getProxy() const;
+
+    using OutgoingAsyncBase::sent;
+    virtual bool completed(const Ice::Exception&);
+    virtual void retryException(const Ice::Exception&);
+    virtual void cancelable(const CancellationHandlerPtr&);
+
+    void retry();
+    void abort(const Ice::Exception&);
+
+protected:
+
+    ProxyOutgoingAsyncBase(const Ice::ObjectPrx&, const std::string&, const CallbackBasePtr&, 
+                           const Ice::LocalObjectPtr&);
+
+    void invokeImpl(bool);
+
+    bool sent(bool);
+    bool finished(const Ice::Exception&);
+    bool finished(bool);
+
+    virtual void handleRetryException(const Ice::Exception&);
+    virtual int handleException(const Ice::Exception&);
+    virtual void runTimerTask();
+
+    const Ice::ObjectPrx _proxy;
+    RequestHandlerPtr _handler;
+    Ice::OperationMode _mode;
+
+private:
+
+    int _cnt;
+    bool _sent;
+};
+
+//
+// Class for handling Slice operation invocations
+//
+class ICE_API OutgoingAsync : public ProxyOutgoingAsyncBase
+{
+public:
+
+    OutgoingAsync(const Ice::ObjectPrx&, const std::string&, const CallbackBasePtr&, const Ice::LocalObjectPtr&);
+
+    void prepare(const std::string&, Ice::OperationMode, const Ice::Context*);
+
+    virtual bool sent();
+
+    virtual AsyncStatus send(const Ice::ConnectionIPtr&, bool, bool);
+    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
+
+    void abort(const Ice::Exception&);
+
+    void invoke();
+    using ProxyOutgoingAsyncBase::completed;
+    bool completed();
+
+    BasicStream* startWriteParams(Ice::FormatType format)
+    {
+        _os.startWriteEncaps(_encoding, format);
+        return &_os;
+    }
+    void endWriteParams()
+    {
+        _os.endWriteEncaps();
+    }
+    void writeEmptyParams()
+    {
+        _os.writeEmptyEncaps(_encoding);
+    }
+    void writeParamEncaps(const ::Ice::Byte* encaps, ::Ice::Int size)
+    {
+        if(size == 0)
+        {
+            _os.writeEmptyEncaps(_encoding);
+        }
+        else
+        {
+            _os.writeEncaps(encaps, size);
+        }
+    }
+
+    BasicStream* getIs()
+    {
+        return &_is;
+    }
+
+private:
+
+    const Ice::EncodingVersion _encoding;
+};
+
+//
+// Class for handling the proxy's begin_ice_flushBatchRequest request.
+//
+class ICE_API ProxyFlushBatch : public ProxyOutgoingAsyncBase
+{
+public:
+
+    ProxyFlushBatch(const Ice::ObjectPrx&, const std::string&, const CallbackBasePtr&, const Ice::LocalObjectPtr&);
+
+    virtual AsyncStatus send(const Ice::ConnectionIPtr&, bool, bool);
+    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
+
+    void invoke();
+
+private:
+
+    virtual void handleRetryException(const Ice::Exception&);
+    virtual int handleException(const Ice::Exception&);
+};
+typedef IceUtil::Handle<ProxyFlushBatch> ProxyFlushBatchPtr;
+
+//
+// Class for handling the proxy's begin_ice_getConnection request.
+//
+class ICE_API ProxyGetConnection :  public ProxyOutgoingAsyncBase
+{
+public:
+
+    ProxyGetConnection(const Ice::ObjectPrx&, const std::string&, const CallbackBasePtr&, const Ice::LocalObjectPtr&);
+
+    virtual AsyncStatus send(const Ice::ConnectionIPtr&, bool, bool);
+    virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
+
+    void invoke();
+};
+typedef IceUtil::Handle<ProxyGetConnection> ProxyGetConnectionPtr;
+
+//
+// Class for handling Ice::Connection::begin_flushBatchRequests
+//
+class ICE_API ConnectionFlushBatch : public OutgoingAsyncBase
+{
+public:
+
+    ConnectionFlushBatch(const Ice::ConnectionIPtr&, const Ice::CommunicatorPtr&, const InstancePtr&,
+                         const std::string&, const CallbackBasePtr&, const Ice::LocalObjectPtr&);
+    
+    virtual Ice::ConnectionPtr getConnection() const;
+
+    void invoke();
+
+private:
+
+    const Ice::ConnectionIPtr _connection;
+};
+typedef IceUtil::Handle<ConnectionFlushBatch> ConnectionFlushBatchPtr;
+
+//
+// Class for handling Ice::Communicator::begin_flushBatchRequests
+//
+class ICE_API CommunicatorFlushBatch : public Ice::AsyncResult
+{
+public:
+
+    CommunicatorFlushBatch(const Ice::CommunicatorPtr&, const InstancePtr&, const std::string&,
+                           const CallbackBasePtr&, const Ice::LocalObjectPtr&);
+
+    void flushConnection(const Ice::ConnectionIPtr&);
+    void ready();
+
+private:
+
+    void check(bool);
+
+    int _useCount;
+};
+
+}
+
+#endif

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

@@ -0,0 +1,38 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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_OUTGOING_ASYNC_F_H
+#define ICE_OUTGOING_ASYNC_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class OutgoingAsyncBase;
+ICE_API IceUtil::Shared* upCast(OutgoingAsyncBase*);
+typedef IceInternal::Handle<OutgoingAsyncBase> OutgoingAsyncBasePtr;
+
+class OutgoingAsync;
+ICE_API IceUtil::Shared* upCast(OutgoingAsync*);
+typedef IceInternal::Handle<OutgoingAsync> OutgoingAsyncPtr;
+
+class ProxyOutgoingAsyncBase;
+ICE_API IceUtil::Shared* upCast(ProxyOutgoingAsyncBase*);
+typedef IceInternal::Handle<ProxyOutgoingAsyncBase> ProxyOutgoingAsyncBasePtr;
+
+class CommunicatorFlushBatch;
+ICE_API IceUtil::Shared* upCast(CommunicatorFlushBatch*);
+typedef IceInternal::Handle<CommunicatorFlushBatch> CommunicatorFlushBatchPtr;
+
+}
+
+#endif

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

@@ -0,0 +1,121 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `Plugin.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef __Ice_Plugin_h__
+#define __Ice_Plugin_h__
+
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ObjectF.h>
+#include <Ice/Exception.h>
+#include <Ice/LocalObject.h>
+#include <Ice/StreamHelpers.h>
+#include <IceUtil/ScopedArray.h>
+#include <IceUtil/Optional.h>
+#include <Ice/LoggerF.h>
+#include <Ice/BuiltinSequences.h>
+#include <IceUtil/UndefSysMacros.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+#ifndef ICE_API
+#   ifdef ICE_API_EXPORTS
+#       define ICE_API ICE_DECLSPEC_EXPORT
+#   else
+#       define ICE_API ICE_DECLSPEC_IMPORT
+#   endif
+#endif
+
+namespace Ice
+{
+
+class Plugin;
+bool operator==(const Plugin&, const Plugin&);
+bool operator<(const Plugin&, const Plugin&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Plugin*);
+typedef ::IceInternal::Handle< ::Ice::Plugin> PluginPtr;
+
+class PluginManager;
+bool operator==(const PluginManager&, const PluginManager&);
+bool operator<(const PluginManager&, const PluginManager&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::PluginManager*);
+typedef ::IceInternal::Handle< ::Ice::PluginManager> PluginManagerPtr;
+
+}
+
+namespace Ice
+{
+
+class ICE_API Plugin : virtual public ::Ice::LocalObject
+{
+public:
+
+    typedef PluginPtr PointerType;
+
+    virtual void initialize() = 0;
+
+    virtual void destroy() = 0;
+};
+
+inline bool operator==(const Plugin& l, const Plugin& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const Plugin& l, const Plugin& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API PluginManager : virtual public ::Ice::LocalObject
+{
+public:
+
+    typedef PluginManagerPtr PointerType;
+
+    virtual void initializePlugins() = 0;
+
+    virtual ::Ice::StringSeq getPlugins() = 0;
+
+    virtual ::Ice::PluginPtr getPlugin(const ::std::string&) = 0;
+
+    virtual void addPlugin(const ::std::string&, const ::Ice::PluginPtr&) = 0;
+
+    virtual void destroy() = 0;
+};
+
+inline bool operator==(const PluginManager& l, const PluginManager& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const PluginManager& l, const PluginManager& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+}
+
+#include <IceUtil/PopDisableWarnings.h>
+#endif

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

@@ -0,0 +1,66 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `PluginF.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef __Ice_PluginF_h__
+#define __Ice_PluginF_h__
+
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/ProxyF.h>
+#include <Ice/ObjectF.h>
+#include <Ice/Exception.h>
+#include <Ice/LocalObject.h>
+#include <Ice/StreamHelpers.h>
+#include <IceUtil/ScopedArray.h>
+#include <IceUtil/Optional.h>
+#include <IceUtil/UndefSysMacros.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+#ifndef ICE_API
+#   ifdef ICE_API_EXPORTS
+#       define ICE_API ICE_DECLSPEC_EXPORT
+#   else
+#       define ICE_API ICE_DECLSPEC_IMPORT
+#   endif
+#endif
+
+namespace Ice
+{
+
+class Plugin;
+bool operator==(const Plugin&, const Plugin&);
+bool operator<(const Plugin&, const Plugin&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Plugin*);
+typedef ::IceInternal::Handle< ::Ice::Plugin> PluginPtr;
+
+class PluginManager;
+bool operator==(const PluginManager&, const PluginManager&);
+bool operator<(const PluginManager&, const PluginManager&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::PluginManager*);
+typedef ::IceInternal::Handle< ::Ice::PluginManager> PluginManagerPtr;
+
+}
+
+#include <IceUtil/PopDisableWarnings.h>
+#endif