zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_OBJECT_ADAPTER_I_H
 #define ICE_OBJECT_ADAPTER_I_H
@@ -36,28 +31,33 @@ namespace Ice
 {
 
 class ObjectAdapterI;
-typedef IceUtil::Handle<ObjectAdapterI> ObjectAdapterIPtr;
+ICE_DEFINE_PTR(ObjectAdapterIPtr, ObjectAdapterI);
+
+class ObjectAdapterI : public ObjectAdapter,
+                       public IceUtil::Monitor<IceUtil::RecMutex>
+#ifdef ICE_CPP11_MAPPING
+                     , public std::enable_shared_from_this<ObjectAdapterI>
+#endif
 
-class ObjectAdapterI : public ObjectAdapter, public IceUtil::Monitor<IceUtil::RecMutex>
 {
 public:
 
-    virtual std::string getName() const;
+    virtual std::string getName() const ICE_NOEXCEPT;
 
-    virtual CommunicatorPtr getCommunicator() const;
+    virtual CommunicatorPtr getCommunicator() const ICE_NOEXCEPT;
 
     virtual void activate();
     virtual void hold();
     virtual void waitForHold();
-    virtual void deactivate();
-    virtual void waitForDeactivate();
-    virtual bool isDeactivated() const;
-    virtual void destroy();
-
-    virtual ObjectPrx add(const ObjectPtr&, const Identity&);
-    virtual ObjectPrx addFacet(const ObjectPtr&, const Identity&, const std::string&);
-    virtual ObjectPrx addWithUUID(const ObjectPtr&);
-    virtual ObjectPrx addFacetWithUUID(const ObjectPtr&, const std::string&);
+    virtual void deactivate() ICE_NOEXCEPT;
+    virtual void waitForDeactivate() ICE_NOEXCEPT;
+    virtual bool isDeactivated() const ICE_NOEXCEPT;
+    virtual void destroy() ICE_NOEXCEPT;
+
+    virtual ObjectPrxPtr add(const ObjectPtr&, const Identity&);
+    virtual ObjectPrxPtr addFacet(const ObjectPtr&, const Identity&, const std::string&);
+    virtual ObjectPrxPtr addWithUUID(const ObjectPtr&);
+    virtual ObjectPrxPtr addFacetWithUUID(const ObjectPtr&, const std::string&);
     virtual void addDefaultServant(const ObjectPtr&, const std::string&);
     virtual ObjectPtr remove(const Identity&);
     virtual ObjectPtr removeFacet(const Identity&, const std::string&);
@@ -66,28 +66,32 @@ public:
     virtual ObjectPtr find(const Identity&) const;
     virtual ObjectPtr findFacet(const Identity&, const std::string&) const;
     virtual FacetMap findAllFacets(const Identity&) const;
-    virtual ObjectPtr findByProxy(const ObjectPrx&) const;
+    virtual ObjectPtr findByProxy(const ObjectPrxPtr&) const;
     virtual ObjectPtr findDefaultServant(const std::string&) const;
 
-
     virtual void addServantLocator(const ServantLocatorPtr&, const std::string&);
     virtual ServantLocatorPtr removeServantLocator(const std::string&);
     virtual ServantLocatorPtr findServantLocator(const std::string&) const;
 
-    virtual ObjectPrx createProxy(const Identity&) const;
-    virtual ObjectPrx createDirectProxy(const Identity&) const;
-    virtual ObjectPrx createIndirectProxy(const Identity&) const;
+    virtual ObjectPrxPtr createProxy(const Identity&) const;
+    virtual ObjectPrxPtr createDirectProxy(const Identity&) const;
+    virtual ObjectPrxPtr createIndirectProxy(const Identity&) const;
+
+    virtual void setLocator(const LocatorPrxPtr&);
+    virtual Ice::LocatorPrxPtr getLocator() const ICE_NOEXCEPT;
+    virtual EndpointSeq getEndpoints() const ICE_NOEXCEPT;
 
-    virtual void setLocator(const LocatorPrx&);
-    virtual Ice::LocatorPrx getLocator() const;
     virtual void refreshPublishedEndpoints();
+    virtual EndpointSeq getPublishedEndpoints() const ICE_NOEXCEPT;
+    virtual void setPublishedEndpoints(const EndpointSeq&);
 
-    virtual EndpointSeq getEndpoints() const;
-    virtual EndpointSeq getPublishedEndpoints() const;
+#ifdef ICE_SWIFT
+    virtual dispatch_queue_t getDispatchQueue() const;
+#endif
 
-    bool isLocal(const ObjectPrx&) const;
+    bool isLocal(const ObjectPrxPtr&) const;
 
-    void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchAsyncPtr&);
+    void flushAsyncBatchRequests(const IceInternal::CommunicatorFlushBatchAsyncPtr&, CompressBatch);
 
     void updateConnectionObservers();
     void updateThreadObservers();
@@ -98,23 +102,25 @@ public:
     IceInternal::ThreadPoolPtr getThreadPool() const;
     IceInternal::ServantManagerPtr getServantManager() const;
     IceInternal::ACMConfig getACM() const;
+    void setAdapterOnConnection(const Ice::ConnectionIPtr&);
     size_t messageSizeMax() const { return _messageSizeMax; }
 
-private:
-
     ObjectAdapterI(const IceInternal::InstancePtr&, const CommunicatorPtr&,
                    const IceInternal::ObjectAdapterFactoryPtr&, const std::string&, bool);
     virtual ~ObjectAdapterI();
-    void initialize(const RouterPrx&);
+
+private:
+
+    void initialize(const RouterPrxPtr&);
     friend class IceInternal::ObjectAdapterFactory;
 
-    ObjectPrx newProxy(const Identity&, const std::string&) const;
-    ObjectPrx newDirectProxy(const Identity&, const std::string&) const;
-    ObjectPrx newIndirectProxy(const Identity&, const std::string&, const std::string&) const;
+    ObjectPrxPtr newProxy(const Identity&, const std::string&) const;
+    ObjectPrxPtr newDirectProxy(const Identity&, const std::string&) const;
+    ObjectPrxPtr newIndirectProxy(const Identity&, const std::string&, const std::string&) const;
     void checkForDeactivation() const;
     std::vector<IceInternal::EndpointIPtr> parseEndpoints(const std::string&, bool) const;
-    std::vector<IceInternal::EndpointIPtr> parsePublishedEndpoints();
-    void updateLocatorRegistry(const IceInternal::LocatorInfoPtr&, const Ice::ObjectPrx&);
+    std::vector<IceInternal::EndpointIPtr> computePublishedEndpoints();
+    void updateLocatorRegistry(const IceInternal::LocatorInfoPtr&, const Ice::ObjectPrxPtr&);
     bool filterProperties(Ice::StringSeq&);
 
     enum State
@@ -140,7 +146,6 @@ private:
     const std::string _replicaGroupId;
     IceInternal::ReferencePtr _reference;
     std::vector<IceInternal::IncomingConnectionFactoryPtr> _incomingConnectionFactories;
-    std::vector<IceInternal::EndpointIPtr> _routerEndpoints;
     IceInternal::RouterInfoPtr _routerInfo;
     std::vector<IceInternal::EndpointIPtr> _publishedEndpoints;
     IceInternal::LocatorInfoPtr _locatorInfo;

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

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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.4
 //
 // <auto-generated>
 //
@@ -23,25 +18,58 @@
 #endif
 #include <Ice/ObjectFactory.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.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 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 4
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
 }
 
-ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::ObjectFactory* p) { return p; }
+Ice::ObjectFactory::~ObjectFactory()
+{
+}
+
+#else // C++98 mapping
+
+namespace
+{
+
+}
+
+Ice::ObjectFactory::~ObjectFactory()
+{
+}
+
+/// \cond INTERNAL
+ICE_API ::Ice::LocalObject* Ice::upCast(ObjectFactory* p) { return p; }
+/// \endcond
+
+namespace Ice
+{
+}
+
+#endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/ObserverHelper.h>
 #include <Ice/Reference.h>
@@ -16,29 +11,14 @@ using namespace std;
 using namespace Ice;
 using namespace Ice::Instrumentation;
 
-namespace
-{
-
-Ice::Context emptyCtx;
-
-}
-
-IceInternal::InvocationObserver::InvocationObserver(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
+IceInternal::InvocationObserver::InvocationObserver(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx)
 {
-    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer;
     if(!obsv)
     {
         return;
     }
-
-    if(ctx)
-    {
-        attach(obsv->getInvocationObserver(proxy, op, *ctx));
-    }
-    else
-    {
-        attach(obsv->getInvocationObserver(proxy, op, emptyCtx));
-    }
+    attach(obsv->getInvocationObserver(proxy, op, ctx));
 }
 
 IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* instance, const string& op)
@@ -49,26 +29,18 @@ IceInternal::InvocationObserver::InvocationObserver(IceInternal::Instance* insta
         return;
     }
 
-    attach(obsv->getInvocationObserver(0, op, emptyCtx));
+    attach(obsv->getInvocationObserver(0, op, noExplicitContext));
 }
 
 void
-IceInternal::InvocationObserver::attach(IceProxy::Ice::Object* proxy, const string& op, const Context* ctx)
+IceInternal::InvocationObserver::attach(const Ice::ObjectPrxPtr& proxy, const string& op, const Context& ctx)
 {
-    const CommunicatorObserverPtr& obsv = proxy->__reference()->getInstance()->initializationData().observer;
+    const CommunicatorObserverPtr& obsv = proxy->_getReference()->getInstance()->initializationData().observer;
     if(!obsv)
     {
         return;
     }
-
-    if(ctx)
-    {
-        attach(obsv->getInvocationObserver(proxy, op, *ctx));
-    }
-    else
-    {
-        attach(obsv->getInvocationObserver(proxy, op, emptyCtx));
-    }
+    attach(obsv->getInvocationObserver(proxy, op, ctx));
 }
 
 void
@@ -80,5 +52,5 @@ IceInternal::InvocationObserver::attach(IceInternal::Instance* instance, const s
         return;
     }
 
-    attach(obsv->getInvocationObserver(0, op, emptyCtx));
+    attach(obsv->getInvocationObserver(0, op, Ice::noExplicitContext));
 }

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

@@ -1,14 +1,10 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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/OpaqueEndpointI.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/Exception.h>
 #include <Ice/DefaultsAndOverrides.h>
 #include <Ice/Base64.h>
@@ -34,22 +30,18 @@ IceInternal::OpaqueEndpointI::OpaqueEndpointI(vector& args) :
 
     if(_type < 0)
     {
-        EndpointParseException ex(__FILE__, __LINE__);
-        ex.str = "no -t option in endpoint " + toString();
-        throw ex;
+        throw EndpointParseException(__FILE__, __LINE__, "no -t option in endpoint " + toString());
     }
     if(_rawBytes.empty())
     {
-        EndpointParseException ex(__FILE__, __LINE__);
-        ex.str = "no -v option in endpoint " + toString();
-        throw ex;
+        throw EndpointParseException(__FILE__, __LINE__, "no -v option in endpoint " + toString());
     }
 }
 
-IceInternal::OpaqueEndpointI::OpaqueEndpointI(Short type, BasicStream* s) : _type(type)
+IceInternal::OpaqueEndpointI::OpaqueEndpointI(Short type, InputStream* s) : _type(type)
 {
-    _rawEncoding = s->getReadEncoding();
-    Int sz = s->getReadEncapsSize();
+    _rawEncoding = s->getEncoding();
+    Int sz = s->getEncapsulationSize();
     s->readBlob(const_cast<vector<Byte>&>(_rawBytes), sz);
 }
 
@@ -60,22 +52,22 @@ class OpaqueEndpointInfoI : public Ice::OpaqueEndpointInfo
 {
 public:
 
-    OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding, const Ice::ByteSeq& rawByes);
+    OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding, const Ice::ByteSeq& rawBytes);
 
     virtual Ice::Short
-    type() const
+    type() const ICE_NOEXCEPT
     {
         return _type;
     }
 
     virtual bool
-    datagram() const
+    datagram() const ICE_NOEXCEPT
     {
         return false;
     }
 
     virtual bool
-    secure() const
+    secure() const ICE_NOEXCEPT
     {
         return false;
     }
@@ -89,25 +81,25 @@ private:
 //
 // COMPILERFIX: inlining this constructor causes crashes with gcc 4.0.1.
 //
-OpaqueEndpointInfoI::OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding,
-                                         const Ice::ByteSeq& rawBytes) :
-    Ice::OpaqueEndpointInfo(-1, false, rawEncoding, rawBytes),
+OpaqueEndpointInfoI::OpaqueEndpointInfoI(Ice::Short type, const Ice::EncodingVersion& rawEncodingP,
+                                         const Ice::ByteSeq& rawBytesP) :
+    Ice::OpaqueEndpointInfo(ICE_NULLPTR, -1, false, rawEncodingP, rawBytesP),
     _type(type)
 {
 }
 
 void
-IceInternal::OpaqueEndpointI::streamWrite(BasicStream* s) const
+IceInternal::OpaqueEndpointI::streamWrite(OutputStream* s) const
 {
-    s->startWriteEncaps(_rawEncoding, DefaultFormat);
+    s->startEncapsulation(_rawEncoding, ICE_ENUM(FormatType, DefaultFormat));
     s->writeBlob(_rawBytes);
-    s->endWriteEncaps();
+    s->endEncapsulation();
 }
 
 Ice::EndpointInfoPtr
-IceInternal::OpaqueEndpointI::getInfo() const
+IceInternal::OpaqueEndpointI::getInfo() const ICE_NOEXCEPT
 {
-    return new OpaqueEndpointInfoI(_type, _rawEncoding, _rawBytes);
+    return ICE_MAKE_SHARED(OpaqueEndpointInfoI, _type, _rawEncoding, _rawBytes);
 }
 
 Short
@@ -131,7 +123,7 @@ IceInternal::OpaqueEndpointI::timeout() const
 EndpointIPtr
 IceInternal::OpaqueEndpointI::timeout(Int) const
 {
-    return const_cast<OpaqueEndpointI*>(this);
+    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
 }
 
 const string&
@@ -143,7 +135,7 @@ IceInternal::OpaqueEndpointI::connectionId() const
 EndpointIPtr
 IceInternal::OpaqueEndpointI::connectionId(const string&) const
 {
-    return const_cast<OpaqueEndpointI*>(this);
+    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
 }
 
 bool
@@ -155,7 +147,7 @@ IceInternal::OpaqueEndpointI::compress() const
 EndpointIPtr
 IceInternal::OpaqueEndpointI::compress(bool) const
 {
-    return const_cast<OpaqueEndpointI*>(this);
+    return ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI);
 }
 
 bool
@@ -173,7 +165,7 @@ IceInternal::OpaqueEndpointI::secure() const
 TransceiverPtr
 IceInternal::OpaqueEndpointI::transceiver() const
 {
-    return 0;
+    return ICE_NULLPTR;
 }
 
 void
@@ -185,14 +177,22 @@ IceInternal::OpaqueEndpointI::connectors_async(Ice::EndpointSelectionType, const
 AcceptorPtr
 IceInternal::OpaqueEndpointI::acceptor(const string&) const
 {
-    return 0;
+    return ICE_NULLPTR;
+}
+
+vector<EndpointIPtr>
+IceInternal::OpaqueEndpointI::expandIfWildcard() const
+{
+    vector<EndpointIPtr> endps;
+    endps.push_back(ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI));
+    return endps;
 }
 
 vector<EndpointIPtr>
-IceInternal::OpaqueEndpointI::expand() const
+IceInternal::OpaqueEndpointI::expandHost(EndpointIPtr&) const
 {
     vector<EndpointIPtr> endps;
-    endps.push_back(const_cast<OpaqueEndpointI*>(this));
+    endps.push_back(ICE_SHARED_FROM_CONST_THIS(OpaqueEndpointI));
     return endps;
 }
 
@@ -202,7 +202,6 @@ IceInternal::OpaqueEndpointI::equivalent(const EndpointIPtr&) const
     return false;
 }
 
-
 Int
 IceInternal::OpaqueEndpointI::hash() const
 {
@@ -231,7 +230,11 @@ IceInternal::OpaqueEndpointI::options() const
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::OpaqueEndpointI::operator==(const Endpoint& r) const
+#else
 IceInternal::OpaqueEndpointI::operator==(const LocalObject& r) const
+#endif
 {
     const OpaqueEndpointI* p = dynamic_cast<const OpaqueEndpointI*>(&r);
     if(!p)
@@ -263,7 +266,11 @@ IceInternal::OpaqueEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::OpaqueEndpointI::operator<(const Endpoint& r) const
+#else
 IceInternal::OpaqueEndpointI::operator<(const LocalObject& r) const
+#endif
 {
     const OpaqueEndpointI* p = dynamic_cast<const OpaqueEndpointI*>(&r);
     if(!p)
@@ -311,6 +318,12 @@ IceInternal::OpaqueEndpointI::operator<(const LocalObject& r) const
     return false;
 }
 
+void
+IceInternal::OpaqueEndpointI::streamWriteImpl(Ice::OutputStream*) const
+{
+    assert(false);
+}
+
 bool
 IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
@@ -320,29 +333,24 @@ IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& ar
     {
         if(_type > -1)
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "multiple -t options in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "multiple -t options in endpoint " + endpoint);
         }
         if(argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -t option in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -t option in endpoint " +
+                                         endpoint);
         }
         istringstream p(argument);
         Ice::Int t;
         if(!(p >> t) || !p.eof())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid type value `" + argument + "' in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "invalid type value `" + argument + "' in endpoint " +
+                                         endpoint);
         }
         else if(t < 0 || t > 65535)
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "type value `" + argument + "' out of range in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "type value `" + argument + "' out of range in endpoint " +
+                                         endpoint);
         }
         _type = static_cast<Ice::Short>(t);
         return true;
@@ -352,26 +360,20 @@ IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& ar
     {
         if(!_rawBytes.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "multiple -v options in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "multiple -v options in endpoint " + endpoint);
         }
         if(argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -v option in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -v option in endpoint " + endpoint);
         }
         for(string::size_type i = 0; i < argument.size(); ++i)
         {
             if(!Base64::isBase64(argument[i]))
             {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ostringstream ostr;
-                ostr << "invalid base64 character `" << argument[i] << "' (ordinal " << static_cast<int>(argument[i])
-                     << ") in endpoint " << endpoint;
-                ex.str = ostr.str();
-                throw ex;
+                ostringstream os;
+                os << "invalid base64 character `" << argument[i] << "' (ordinal " << static_cast<int>(argument[i])
+                   << ") in endpoint " << endpoint;
+                throw EndpointParseException(__FILE__, __LINE__, os.str());
             }
         }
         const_cast<vector<Byte>&>(_rawBytes) = Base64::decode(argument);
@@ -382,20 +384,18 @@ IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& ar
     {
         if(argument.empty())
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -e option in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -e option in endpoint " +
+                                              endpoint);
         }
 
         try
         {
             _rawEncoding = Ice::stringToEncodingVersion(argument);
         }
-        catch(const Ice::VersionParseException& e)
+        catch(const Ice::VersionParseException& ex)
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid encoding version `" + argument + "' in endpoint " + endpoint + ":\n" + e.str;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "invalid encoding version `" + argument +
+                                              "' in endpoint " + endpoint + ":\n" + ex.str);
         }
         return true;
     }