zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -23,22 +23,44 @@
 #endif
 #include <Ice/EndpointF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/Iterator.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 != 306
+#   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 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+}
+
+#else // C++98 mapping
+
 namespace
 {
 
 }
+
+namespace Ice
+{
+}
+
+#endif

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -10,6 +10,7 @@
 #include <Ice/EndpointFactory.h>
 #include <Ice/Instance.h>
 #include <Ice/EndpointFactoryManager.h>
+#include <Ice/ProtocolInstance.h>
 
 using namespace std;
 using namespace Ice;
@@ -25,6 +26,12 @@ IceInternal::EndpointFactory::~EndpointFactory()
 {
 }
 
+void
+IceInternal::EndpointFactory::initialize()
+{
+    // Nothing to do, can be overriden by specialization to finish initialization.
+}
+
 IceInternal::EndpointFactoryPlugin::EndpointFactoryPlugin(const CommunicatorPtr& communicator,
                                                           const EndpointFactoryPtr& factory)
 {
@@ -41,3 +48,147 @@ void
 IceInternal::EndpointFactoryPlugin::destroy()
 {
 }
+
+IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(const ProtocolInstancePtr& instance,
+                                                                          Short type) :
+    _instance(instance), _type(type)
+{
+}
+
+void
+IceInternal::EndpointFactoryWithUnderlying::initialize()
+{
+    //
+    // Get the endpoint factory for the underlying type and clone it with
+    // our protocol instance.
+    //
+    EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
+    if(factory)
+    {
+        _underlying = factory->clone(_instance);
+        _underlying->initialize();
+    }
+}
+
+Short
+IceInternal::EndpointFactoryWithUnderlying::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::EndpointFactoryWithUnderlying::protocol() const
+{
+    return _instance->protocol();
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryWithUnderlying::create(vector<string>& args, bool oaEndpoint) const
+{
+    if(!_underlying)
+    {
+        return 0; // Can't create an endpoint without underlying factory.
+    }
+    return createWithUnderlying(_underlying->create(args, oaEndpoint), args, oaEndpoint);
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryWithUnderlying::read(InputStream* s) const
+{
+    if(!_underlying)
+    {
+        return 0; // Can't create an endpoint without underlying factory.
+    }
+    return readWithUnderlying(_underlying->read(s), s);
+}
+
+void
+IceInternal::EndpointFactoryWithUnderlying::destroy()
+{
+    if(_underlying)
+    {
+        _underlying->destroy();
+    }
+    _instance = 0;
+}
+
+EndpointFactoryPtr
+IceInternal::EndpointFactoryWithUnderlying::clone(const ProtocolInstancePtr& instance) const
+{
+    return cloneWithUnderlying(instance, _type);
+}
+
+IceInternal::UnderlyingEndpointFactory::UnderlyingEndpointFactory(const ProtocolInstancePtr& instance,
+                                                                  Short type,
+                                                                  Short underlying) :
+    _instance(instance), _type(type), _underlying(underlying)
+{
+}
+
+void
+IceInternal::UnderlyingEndpointFactory::initialize()
+{
+    //
+    // Get the endpoint factory of the given endpoint type. If it's a factory that
+    // delegates to an underlying endpoint, clone it and instruct it to delegate to
+    // our underlying factory.
+    //
+    EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
+    if(factory)
+    {
+        EndpointFactoryWithUnderlying* f = dynamic_cast<EndpointFactoryWithUnderlying*>(factory.get());
+        if(f)
+        {
+            _factory = f->cloneWithUnderlying(_instance, _underlying);
+            _factory->initialize();
+        }
+    }
+}
+
+Short
+IceInternal::UnderlyingEndpointFactory::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::UnderlyingEndpointFactory::protocol() const
+{
+    return _instance->protocol();
+}
+
+EndpointIPtr
+IceInternal::UnderlyingEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
+{
+    if(!_factory)
+    {
+        return 0;
+    }
+    return _factory->create(args, oaEndpoint);
+}
+
+EndpointIPtr
+IceInternal::UnderlyingEndpointFactory::read(InputStream* s) const
+{
+    if(!_factory)
+    {
+        return 0;
+    }
+    return _factory->read(s);
+}
+
+void
+IceInternal::UnderlyingEndpointFactory::destroy()
+{
+    if(_factory)
+    {
+        _factory->destroy();
+    }
+    _instance = 0;
+}
+
+EndpointFactoryPtr
+IceInternal::UnderlyingEndpointFactory::clone(const ProtocolInstancePtr& instance) const
+{
+    return new UnderlyingEndpointFactory(instance, _type, _underlying);
+}

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -17,10 +17,15 @@
 #include <Ice/CommunicatorF.h>
 #include <Ice/Plugin.h>
 
-namespace IceInternal
+namespace Ice
 {
 
-class BasicStream;
+class InputStream;
+
+}
+
+namespace IceInternal
+{
 
 class ICE_API EndpointFactory : public ::IceUtil::Shared
 {
@@ -28,10 +33,11 @@ public:
 
     virtual ~EndpointFactory();
 
-    virtual ::Ice::Short type() const = 0;
-    virtual ::std::string protocol() const = 0;
+    virtual void initialize();
+    virtual Ice::Short type() const = 0;
+    virtual std::string protocol() const = 0;
     virtual EndpointIPtr create(std::vector<std::string>&, bool) const = 0;
-    virtual EndpointIPtr read(BasicStream*) const = 0;
+    virtual EndpointIPtr read(Ice::InputStream*) const = 0;
     virtual void destroy() = 0;
 
     virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const = 0;
@@ -41,6 +47,66 @@ protected:
     EndpointFactory();
 };
 
+//
+// The endpoint factory with underlying create endpoints that delegate to an underlying
+// endpoint (e.g.: the SSL/WS endpoints are endpoints with underlying endpoints).
+//
+class ICE_API EndpointFactoryWithUnderlying : public EndpointFactory
+{
+public:
+
+    EndpointFactoryWithUnderlying(const ProtocolInstancePtr&, Ice::Short);
+
+    virtual void initialize();
+    virtual Ice::Short type() const;
+    virtual std::string protocol() const;
+    virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
+    virtual EndpointIPtr read(Ice::InputStream*) const;
+    virtual void destroy();
+
+    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;
+
+    virtual EndpointFactoryPtr cloneWithUnderlying(const ProtocolInstancePtr&, Ice::Short) const = 0;
+
+protected:
+
+    virtual EndpointIPtr createWithUnderlying(const EndpointIPtr&, std::vector<std::string>&, bool) const = 0;
+    virtual EndpointIPtr readWithUnderlying(const EndpointIPtr&, Ice::InputStream*) const = 0;
+
+    ProtocolInstancePtr _instance;
+    const Ice::Short _type;
+    EndpointFactoryPtr _underlying;
+};
+
+//
+// The underlying endpoint factory creates endpoints with a factory of the given
+// type. If this factory is of the EndpointFactoryWithUnderlying type, it will
+// delegate to the given underlying factory (this is used by IceIAP/IceBT plugins
+// for the BTS/iAPS endpoint factories).
+//
+class ICE_API UnderlyingEndpointFactory : public EndpointFactory
+{
+public:
+
+    UnderlyingEndpointFactory(const ProtocolInstancePtr&, Ice::Short, Ice::Short);
+
+    virtual void initialize();
+    virtual Ice::Short type() const;
+    virtual std::string protocol() const;
+    virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
+    virtual EndpointIPtr read(Ice::InputStream*) const;
+    virtual void destroy();
+
+    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;
+
+private:
+
+    ProtocolInstancePtr _instance;
+    const Ice::Short _type;
+    const Ice::Short _underlying;
+    EndpointFactoryPtr _factory;
+};
+
 class ICE_API EndpointFactoryPlugin : public Ice::Plugin
 {
 public:

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -10,7 +10,8 @@
 #include <Ice/EndpointFactoryManager.h>
 #include <Ice/Endpoint.h>
 #include <Ice/OpaqueEndpointI.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/LocalException.h>
 #include <Ice/Instance.h>
 #include <Ice/Properties.h>
@@ -28,6 +29,15 @@ IceInternal::EndpointFactoryManager::EndpointFactoryManager(const InstancePtr& i
 {
 }
 
+void
+IceInternal::EndpointFactoryManager::initialize() const
+{
+    for(vector<EndpointFactoryPtr>::size_type i = 0; i < _factories.size(); i++)
+    {
+        _factories[i]->initialize();
+    }
+}
+
 void
 IceInternal::EndpointFactoryManager::add(const EndpointFactoryPtr& factory)
 {
@@ -61,7 +71,7 @@ IceInternal::EndpointFactoryManager::get(Short type) const
             return _factories[i];
         }
     }
-    return 0;
+    return ICE_NULLPTR;
 }
 
 EndpointIPtr
@@ -122,14 +132,14 @@ IceInternal::EndpointFactoryManager::create(const string& str, bool oaEndpoint)
         // Code below left in place for debugging.
 
         EndpointIPtr e = factory->create(str.substr(end), oaEndpoint);
-        BasicStream bs(_instance.get(), Ice::currentProtocolEncoding);
+        OutputStream bs(_instance.get(), Ice::currentProtocolEncoding);
         e->streamWrite(&bs);
         bs.i = bs.b.begin();
         short type;
         bs.read(type);
         EndpointIPtr ue = new IceInternal::OpaqueEndpointI(type, &bs);
-        cerr << "Normal: " << e->toString() << endl;
-        cerr << "Opaque: " << ue->toString() << endl;
+        consoleErr << "Normal: " << e->toString() << endl;
+        consoleErr << "Opaque: " << ue->toString() << endl;
         return e;
 #endif
     }
@@ -140,7 +150,7 @@ IceInternal::EndpointFactoryManager::create(const string& str, bool oaEndpoint)
     //
     if(protocol == "opaque")
     {
-        EndpointIPtr ue = new OpaqueEndpointI(v);
+        EndpointIPtr ue = ICE_MAKE_SHARED(OpaqueEndpointI, v);
         if(!v.empty())
         {
             EndpointParseException ex(__FILE__, __LINE__);
@@ -155,25 +165,25 @@ IceInternal::EndpointFactoryManager::create(const string& str, bool oaEndpoint)
             // and ask the factory to read the endpoint data from that stream to create
             // the actual endpoint.
             //
-            BasicStream bs(_instance.get(), Ice::currentProtocolEncoding);
+            OutputStream bs(_instance.get(), Ice::currentProtocolEncoding);
             bs.write(ue->type());
             ue->streamWrite(&bs);
-            bs.i = bs.b.begin();
+            InputStream is(bs.instance(), bs.getEncoding(), bs);
             short type;
-            bs.read(type);
-            bs.startReadEncaps();
-            EndpointIPtr e = factory->read(&bs);
-            bs.endReadEncaps();
+            is.read(type);
+            is.startEncapsulation();
+            EndpointIPtr e = factory->read(&is);
+            is.endEncapsulation();
             return e;
         }
         return ue; // Endpoint is opaque, but we don't have a factory for its type.
     }
 
-    return 0;
+    return ICE_NULLPTR;
 }
 
 EndpointIPtr
-IceInternal::EndpointFactoryManager::read(BasicStream* s) const
+IceInternal::EndpointFactoryManager::read(InputStream* s) const
 {
     Short type;
     s->read(type);
@@ -181,18 +191,24 @@ IceInternal::EndpointFactoryManager::read(BasicStream* s) const
     EndpointFactoryPtr factory = get(type);
     EndpointIPtr e;
 
-    s->startReadEncaps();
+    s->startEncapsulation();
 
     if(factory)
     {
         e = factory->read(s);
     }
-    else
+    //
+    // If the factory failed to read the endpoint, return an opaque endpoint. This can
+    // occur if for example the factory delegates to another factory and this factory
+    // isn't available. In this case, the factory needs to make sure the stream position
+    // is preserved for reading the opaque endpoint.
+    //
+    if(!e)
     {
-        e = new OpaqueEndpointI(type, s);
+        e = ICE_MAKE_SHARED(OpaqueEndpointI, type, s);
     }
 
-    s->endReadEncaps();
+    s->endEncapsulation();
 
     return e;
 }