zeroc-ice 3.6b1

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

@@ -0,0 +1,74 @@
+// **********************************************************************
+//
+// 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_NETWORK_PROXY_H
+#define ICE_NETWORK_PROXY_H
+
+#include <Ice/Network.h>
+
+namespace IceInternal
+{
+
+class ICE_API NetworkProxy : virtual public IceUtil::Shared
+{
+public:
+
+    //
+    // Write the connection request on the connection established
+    // with the network proxy server. This is called right after
+    // the connection establishment succeeds.
+    //
+    virtual void beginWrite(const Address&, Buffer&) = 0;
+    virtual SocketOperation endWrite(Buffer&) = 0;
+
+    //
+    // Once the connection request has been sent, this is called
+    // to prepare and read the response from the proxy server.
+    //
+    virtual void beginRead(Buffer&) = 0;
+    virtual SocketOperation endRead(Buffer&) = 0;
+
+    //
+    // This is called when the response from the proxy has been
+    // read. The proxy should copy the extra read data (if any) in the
+    // given byte vector.
+    //
+    virtual void finish(Buffer&, Buffer&) = 0;
+
+    //
+    // If the proxy host needs to be resolved, this should return
+    // a new NetworkProxy containing the IP address of the proxy.
+    // This is called from the endpoint host resolver thread, so
+    // it's safe if this this method blocks.
+    //
+    virtual NetworkProxyPtr resolveHost(ProtocolSupport) const = 0;
+
+    //
+    // Returns the IP address of the network proxy. This method
+    // must not block. It's only called on a network proxy object
+    // returned by resolveHost().
+    //
+    virtual Address getAddress() const = 0;
+
+    //
+    // Returns the name of the proxy, used for tracing purposes.
+    //
+    virtual std::string getName() const = 0;
+
+    //
+    // Returns the protocols supported by the proxy.
+    //
+    virtual ProtocolSupport getProtocolSupport() const = 0;
+};
+
+NetworkProxyPtr createNetworkProxy(const Ice::PropertiesPtr&, ProtocolSupport);
+
+}
+
+#endif

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

@@ -0,0 +1,26 @@
+// **********************************************************************
+//
+// 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_NETWORK_PROXY_F_H
+#define ICE_NETWORK_PROXY_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class NetworkProxy;
+ICE_API IceUtil::Shared* upCast(NetworkProxy*);
+typedef Handle<NetworkProxy> NetworkProxyPtr;
+
+}
+
+#endif

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

@@ -0,0 +1,440 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#include <Ice/Object.h>
+#include <Ice/Incoming.h>
+#include <Ice/IncomingAsync.h>
+#include <Ice/IncomingRequest.h>
+#include <Ice/LocalException.h>
+#include <Ice/Stream.h>
+#include <Ice/SlicedData.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+Object* Ice::upCast(Object* p) { return p; }
+
+void 
+Ice::__patch(ObjectPtr& obj, const ObjectPtr& v)
+{
+    obj = v;
+}
+
+bool
+Ice::Object::operator==(const Object& r) const
+{
+    return this == &r;
+}
+
+bool
+Ice::Object::operator<(const Object& r) const
+{
+    return this < &r;
+}
+
+
+namespace
+{
+
+const string __Ice__Object_ids[] =
+{
+    "::Ice::Object"
+};
+
+}
+
+bool
+Ice::Object::ice_isA(const string& s, const Current&) const
+{
+    return s == __Ice__Object_ids[0];
+}
+
+void
+Ice::Object::ice_ping(const Current&) const
+{
+    // Nothing to do.
+}
+
+vector<string>
+Ice::Object::ice_ids(const Current&) const
+{
+    return vector<string>(&__Ice__Object_ids[0], &__Ice__Object_ids[1]);
+}
+
+const string&
+Ice::Object::ice_id(const Current&) const
+{
+    return __Ice__Object_ids[0];
+}
+
+const ::std::string&
+Ice::Object::ice_staticId()
+{
+    return __Ice__Object_ids[0];
+}
+
+Ice::ObjectPtr
+Ice::Object::ice_clone() const
+{
+    throw CloneNotImplementedException(__FILE__, __LINE__);
+    return 0; // avoid warning with some compilers
+}
+
+void
+Ice::Object::ice_preMarshal()
+{
+}
+
+void
+Ice::Object::ice_postUnmarshal()
+{
+}
+
+DispatchStatus
+Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
+{
+    BasicStream* __is = __inS.startReadParams();
+    string __id;
+    __is->read(__id, false);
+    __inS.endReadParams();
+    bool __ret = ice_isA(__id, __current);
+    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
+    __os->write(__ret);
+    __inS.__endWriteParams(true);
+    return DispatchOK;
+}
+
+DispatchStatus
+Ice::Object::___ice_ping(Incoming& __inS, const Current& __current)
+{
+    __inS.readEmptyParams();
+    ice_ping(__current);
+    __inS.__writeEmptyParams();
+    return DispatchOK;
+}
+
+DispatchStatus
+Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
+{
+    __inS.readEmptyParams();
+    vector<string> __ret = ice_ids(__current);
+    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
+    __os->write(&__ret[0], &__ret[0] + __ret.size(), false);
+    __inS.__endWriteParams(true);
+    return DispatchOK;
+}
+
+DispatchStatus
+Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
+{
+    __inS.readEmptyParams();
+    string __ret = ice_id(__current);
+    BasicStream* __os = __inS.__startWriteParams(DefaultFormat);
+    __os->write(__ret, false);
+    __inS.__endWriteParams(true);
+    return DispatchOK;
+}
+
+Ice::Int
+Ice::Object::ice_operationAttributes(const string&) const
+{
+    return 0;
+}
+
+
+string Ice::Object::__all[] =
+{
+    "ice_id",
+    "ice_ids",
+    "ice_isA",
+    "ice_ping"
+};
+
+
+DispatchStatus
+Ice::Object::ice_dispatch(Request& request, const DispatchInterceptorAsyncCallbackPtr& cb)
+{
+    class PushCb
+    {
+    public:
+        PushCb(IceInternal::Incoming& in, const DispatchInterceptorAsyncCallbackPtr& cb) :
+            _in(in),
+            _cb(cb)
+        {
+            if(_cb != 0)
+            {
+                _in.push(_cb);
+            }
+        }
+
+        ~PushCb()
+        {
+            if(_cb != 0)
+            {
+                _in.pop();
+            }
+        }
+    private:
+        IceInternal::Incoming& _in;
+        const DispatchInterceptorAsyncCallbackPtr& _cb;
+    };
+
+
+    IceInternal::Incoming& in = dynamic_cast<IceInternal::IncomingRequest&>(request)._in;
+    
+    PushCb pusbCb(in, cb);
+    in.startOver(); // may raise ResponseSentException
+    return __dispatch(in, in.getCurrent());
+}
+
+DispatchStatus
+Ice::Object::__dispatch(Incoming& in, const Current& current)
+{
+    pair<string*, string*> r =
+        equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation);
+
+    if(r.first == r.second)
+    {
+        throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+    }                                        
+
+    switch(r.first - __all)
+    {
+        case 0:
+        {
+            return ___ice_id(in, current);
+        }
+        case 1:
+        {
+            return ___ice_ids(in, current);
+        }
+        case 2:
+        {
+            return ___ice_isA(in, current);
+        }
+        case 3:
+        {
+            return ___ice_ping(in, current);
+        }
+    }
+
+    assert(false);
+    throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
+}
+
+void
+Ice::Object::__write(IceInternal::BasicStream* os) const
+{
+    os->startWriteObject(0);
+    __writeImpl(os);
+    os->endWriteObject();
+}
+ 
+void 
+Ice::Object::__read(IceInternal::BasicStream* is)
+{
+   is->startReadObject();
+   __readImpl(is);
+   is->endReadObject(false);
+}
+    
+void 
+Ice::Object::__write(const OutputStreamPtr& os) const
+{
+    os->startObject(0);
+    __writeImpl(os);
+    os->endObject();
+}
+ 
+void 
+Ice::Object::__read(const InputStreamPtr& is)
+{
+    is->startObject();
+   __readImpl(is);
+   is->endObject(false);
+}
+ 
+void 
+Ice::Object::__writeImpl(const OutputStreamPtr&) const
+{
+    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+}
+ 
+void 
+Ice::Object::__readImpl(const InputStreamPtr&)
+{
+    throw MarshalException(__FILE__, __LINE__, "class was not generated with stream support");
+}
+
+namespace
+{
+
+string
+operationModeToString(OperationMode mode)
+{
+    switch(mode)
+    {
+    case Normal:
+        return "::Ice::Normal";
+
+    case Nonmutating:
+        return "::Ice::Nonmutating";
+
+    case Idempotent:
+        return "::Ice::Idempotent";
+    }
+
+    ostringstream os;
+    os << "unknown value (" << mode << ")";
+    return os.str();
+}
+
+}
+
+void
+Ice::Object::__checkMode(OperationMode expected, OperationMode received)
+{
+    if(expected != received)
+    {
+        if(expected == Idempotent && received == Nonmutating)
+        {
+            // 
+            // Fine: typically an old client still using the deprecated nonmutating keyword
+            //
+            
+            //
+            // Note that expected == Nonmutating and received == Idempotent is not ok:
+            // the server may still use the deprecated nonmutating keyword to detect updates
+            // and the client should not break this (deprecated) feature.
+            //
+        }
+        else
+        {
+            Ice::MarshalException ex(__FILE__, __LINE__);
+            std::ostringstream __reason;
+            __reason << "unexpected operation mode. expected = "
+                     << operationModeToString(expected)
+                     << " received = "
+                     << operationModeToString(received);
+            ex.reason = __reason.str();
+            throw ex;
+        }
+    }
+}
+
+DispatchStatus
+Ice::Blobject::__dispatch(Incoming& in, const Current& current)
+{
+    const Byte* inEncaps;
+    Int sz;
+    in.readParamEncaps(inEncaps, sz);
+    vector<Byte> outEncaps;
+    bool ok = ice_invoke(vector<Byte>(inEncaps, inEncaps + sz), outEncaps, current);
+    if(outEncaps.empty())
+    {
+        in.__writeParamEncaps(0, 0, ok);
+    }
+    else
+    {
+        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
+    }
+    if(ok)
+    {
+        return DispatchOK;
+    }
+    else
+    {
+        return DispatchUserException;
+    }
+}
+
+DispatchStatus
+Ice::BlobjectArray::__dispatch(Incoming& in, const Current& current)
+{
+    pair<const Byte*, const Byte*> inEncaps;
+    Int sz;
+    in.readParamEncaps(inEncaps.first, sz);
+    inEncaps.second = inEncaps.first + sz;
+    vector<Byte> outEncaps;
+    bool ok = ice_invoke(inEncaps, outEncaps, current);
+    if(outEncaps.empty())
+    {
+        in.__writeParamEncaps(0, 0, ok);
+    }
+    else
+    {
+        in.__writeParamEncaps(&outEncaps[0], static_cast<Ice::Int>(outEncaps.size()), ok);
+    }
+    if(ok)
+    {
+        return DispatchOK;
+    }
+    else
+    {
+        return DispatchUserException;
+    }
+}
+
+DispatchStatus
+Ice::BlobjectAsync::__dispatch(Incoming& in, const Current& current)
+{
+    const Byte* inEncaps;
+    Int sz;
+    in.readParamEncaps(inEncaps, sz);
+    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
+    try
+    {
+        ice_invoke_async(cb, vector<Byte>(inEncaps, inEncaps + sz), current);
+    }
+    catch(const ::std::exception& ex)
+    {
+        cb->ice_exception(ex);
+    }
+    catch(...)
+    {
+        cb->ice_exception();
+    }
+    return DispatchAsync;
+}
+
+DispatchStatus
+Ice::BlobjectArrayAsync::__dispatch(Incoming& in, const Current& current)
+{
+    pair<const Byte*, const Byte*> inEncaps;
+    Int sz;
+    in.readParamEncaps(inEncaps.first, sz);
+    inEncaps.second = inEncaps.first + sz;
+    AMD_Object_ice_invokePtr cb = new ::IceAsync::Ice::AMD_Object_ice_invoke(in);
+    try
+    {
+        ice_invoke_async(cb, inEncaps, current);
+    }
+    catch(const ::std::exception& ex)
+    {
+        cb->ice_exception(ex);
+    }
+    catch(...)
+    {
+        cb->ice_exception();
+    }
+    return DispatchAsync;
+}
+
+void
+Ice::ice_writeObject(const OutputStreamPtr& out, const ObjectPtr& p)
+{
+    out->write(p);
+}
+
+void
+Ice::ice_readObject(const InputStreamPtr& in, ObjectPtr& p)
+{
+    in->read(p);
+}