zeroc-ice 3.6b1

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

@@ -0,0 +1,262 @@
+// **********************************************************************
+//
+// 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_INSTRUMENTATION_I_H
+#define ICE_INSTRUMENTATION_I_H
+
+#include <Ice/MetricsObserverI.h>
+#include <Ice/Connection.h>
+
+namespace IceInternal
+{
+
+template<typename T, typename O> class ObserverWithDelegateT : public IceMX::ObserverT<T>, virtual public O
+{
+public:
+
+    typedef O ObserverType;
+    typedef typename IceInternal::Handle<O> ObserverPtrType;
+
+    virtual void 
+    attach()
+    {
+        IceMX::ObserverT<T>::attach();
+        if(_delegate)
+        {
+            _delegate->attach();
+        }
+    }
+
+    virtual void 
+    detach()
+    {
+        IceMX::ObserverT<T>::detach();
+        if(_delegate)
+        {
+            _delegate->detach();
+        }
+    }
+
+    virtual void
+    failed(const std::string& exceptionName)
+    {
+        IceMX::ObserverT<T>::failed(exceptionName);
+        if(_delegate)
+        {
+            _delegate->failed(exceptionName);
+        }
+    }
+
+    ObserverPtrType
+    getDelegate() const
+    {
+        return _delegate;
+    }
+
+    void
+    setDelegate(ObserverPtrType delegate)
+    {
+        _delegate = delegate;
+    }
+
+    template<typename ObserverImpl, typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserverWithDelegate(const std::string& mapName, const IceMX::MetricsHelperT<ObserverMetricsType>& helper, 
+                            const ObserverPtrType& del)
+    {
+        IceInternal::Handle<ObserverImpl> obsv = IceMX::ObserverT<T>::template getObserver<ObserverImpl>(mapName, 
+                                                                                                         helper);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+
+protected:
+
+    ObserverPtrType _delegate;
+};
+
+template<typename T> class ObserverFactoryWithDelegateT : public IceMX::ObserverFactoryT<T>
+{
+public:
+
+    ObserverFactoryWithDelegateT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) : 
+        IceMX::ObserverFactoryT<T>(metrics, name)
+    {
+    }
+
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del)
+    {
+        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+
+    template<typename ObserverMetricsType, typename ObserverPtrType> ObserverPtrType 
+    getObserverWithDelegate(const IceMX::MetricsHelperT<ObserverMetricsType>& helper, const ObserverPtrType& del, 
+                            const ObserverPtrType& old)
+    {
+        IceInternal::Handle<T> obsv = IceMX::ObserverFactoryT<T>::getObserver(helper, old);
+        if(obsv)
+        {
+            obsv->setDelegate(del);
+            return obsv;
+        }
+        return del;
+    }
+};
+
+template<typename Helper>
+void addEndpointAttributes(typename Helper::Attributes& attrs)
+{
+    attrs.add("endpoint", &Helper::getEndpoint);
+
+    attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type);
+    attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram);
+    attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure);
+    attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout);
+    attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress);
+    
+    attrs.add("endpointHost", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::host);
+    attrs.add("endpointPort", &Helper::getEndpointInfo, &Ice::IPEndpointInfo::port);
+}
+
+template<typename Helper>
+void addConnectionAttributes(typename Helper::Attributes& attrs)
+{
+    attrs.add("incoming", &Helper::getConnectionInfo, &Ice::ConnectionInfo::incoming);
+    attrs.add("adapterName", &Helper::getConnectionInfo, &Ice::ConnectionInfo::adapterName);
+    attrs.add("connectionId", &Helper::getConnectionInfo, &Ice::ConnectionInfo::connectionId);
+    
+    attrs.add("localHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localAddress);
+    attrs.add("localPort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::localPort);
+    attrs.add("remoteHost", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remoteAddress);
+    attrs.add("remotePort", &Helper::getConnectionInfo, &Ice::IPConnectionInfo::remotePort);
+            
+    attrs.add("mcastHost", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastAddress);
+    attrs.add("mcastPort", &Helper::getConnectionInfo, &Ice::UDPConnectionInfo::mcastPort);
+    
+    addEndpointAttributes<Helper>(attrs);
+}
+
+class ConnectionObserverI : public ObserverWithDelegateT<IceMX::ConnectionMetrics, 
+                                                         Ice::Instrumentation::ConnectionObserver>
+{
+public:
+
+    virtual void sentBytes(Ice::Int);
+    virtual void receivedBytes(Ice::Int);
+};
+
+class ThreadObserverI : public ObserverWithDelegateT<IceMX::ThreadMetrics, Ice::Instrumentation::ThreadObserver>
+{
+public:
+
+    virtual void stateChanged(Ice::Instrumentation::ThreadState, Ice::Instrumentation::ThreadState);
+};
+
+class DispatchObserverI : public ObserverWithDelegateT<IceMX::DispatchMetrics, Ice::Instrumentation::DispatchObserver>
+{
+public:
+
+    virtual void userException();
+
+    virtual void reply(Ice::Int);
+};
+
+class RemoteObserverI : public ObserverWithDelegateT<IceMX::RemoteMetrics, Ice::Instrumentation::RemoteObserver>
+{
+public:
+
+    virtual void reply(Ice::Int);
+};
+
+class CollocatedObserverI : public ObserverWithDelegateT<IceMX::CollocatedMetrics, 
+                                                         Ice::Instrumentation::CollocatedObserver>
+{
+public:
+
+    virtual void reply(Ice::Int);
+};
+
+class InvocationObserverI : public ObserverWithDelegateT<IceMX::InvocationMetrics, 
+                                                         Ice::Instrumentation::InvocationObserver>
+{
+public:
+
+    virtual void retried();
+
+    virtual void userException();
+
+    virtual Ice::Instrumentation::RemoteObserverPtr 
+    getRemoteObserver(const Ice::ConnectionInfoPtr&, const Ice::EndpointPtr&, Ice::Int, Ice::Int);
+
+    virtual Ice::Instrumentation::CollocatedObserverPtr
+    getCollocatedObserver(const Ice::ObjectAdapterPtr&, Ice::Int, Ice::Int);
+};
+
+typedef ObserverWithDelegateT<IceMX::Metrics, Ice::Instrumentation::Observer> ObserverI;
+
+class ICE_API CommunicatorObserverI : public Ice::Instrumentation::CommunicatorObserver
+{
+public:
+
+    CommunicatorObserverI(const Ice::InitializationData&);
+
+    virtual void setObserverUpdater(const Ice::Instrumentation::ObserverUpdaterPtr&);
+ 
+    virtual Ice::Instrumentation::ObserverPtr getConnectionEstablishmentObserver(const Ice::EndpointPtr&,
+                                                                                 const std::string&);
+ 
+    virtual Ice::Instrumentation::ObserverPtr getEndpointLookupObserver(const Ice::EndpointPtr&);
+    
+    virtual Ice::Instrumentation::ConnectionObserverPtr 
+    getConnectionObserver(const Ice::ConnectionInfoPtr&, 
+                          const Ice::EndpointPtr&,
+                          Ice::Instrumentation::ConnectionState, 
+                          const Ice::Instrumentation::ConnectionObserverPtr&);
+
+    virtual Ice::Instrumentation::ThreadObserverPtr getThreadObserver(const std::string&, const std::string&,
+                                                                      Ice::Instrumentation::ThreadState,
+                                                                      const Ice::Instrumentation::ThreadObserverPtr&);
+
+    virtual Ice::Instrumentation::InvocationObserverPtr getInvocationObserver(const Ice::ObjectPrx&, 
+                                                                              const std::string&,
+                                                                              const Ice::Context&);
+
+    virtual Ice::Instrumentation::DispatchObserverPtr getDispatchObserver(const Ice::Current&, Ice::Int);
+
+    const IceInternal::MetricsAdminIPtr& getFacet() const;
+
+    void destroy();
+
+private:
+
+    IceInternal::MetricsAdminIPtr _metrics;
+    const Ice::Instrumentation::CommunicatorObserverPtr _delegate;
+
+    ObserverFactoryWithDelegateT<ConnectionObserverI> _connections;
+    ObserverFactoryWithDelegateT<DispatchObserverI> _dispatch;
+    ObserverFactoryWithDelegateT<InvocationObserverI> _invocations;
+    ObserverFactoryWithDelegateT<ThreadObserverI> _threads;
+    ObserverFactoryWithDelegateT<ObserverI> _connects;
+    ObserverFactoryWithDelegateT<ObserverI> _endpointLookups;
+};
+typedef IceUtil::Handle<CommunicatorObserverI> CommunicatorObserverIPtr;
+
+};
+
+#endif

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

@@ -0,0 +1,2091 @@
+// **********************************************************************
+//
+// 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 `LocalException.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/LocalException.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/BasicStream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.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
+
+Ice::InitializationException::InitializationException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::InitializationException::InitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::LocalException(__file, __line),
+    reason(__ice_reason)
+{
+}
+
+Ice::InitializationException::~InitializationException() throw()
+{
+}
+
+::std::string
+Ice::InitializationException::ice_name() const
+{
+    return "Ice::InitializationException";
+}
+
+Ice::InitializationException*
+Ice::InitializationException::ice_clone() const
+{
+    return new InitializationException(*this);
+}
+
+void
+Ice::InitializationException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::PluginInitializationException::PluginInitializationException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::LocalException(__file, __line),
+    reason(__ice_reason)
+{
+}
+
+Ice::PluginInitializationException::~PluginInitializationException() throw()
+{
+}
+
+::std::string
+Ice::PluginInitializationException::ice_name() const
+{
+    return "Ice::PluginInitializationException";
+}
+
+Ice::PluginInitializationException*
+Ice::PluginInitializationException::ice_clone() const
+{
+    return new PluginInitializationException(*this);
+}
+
+void
+Ice::PluginInitializationException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CollocationOptimizationException::CollocationOptimizationException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::CollocationOptimizationException::~CollocationOptimizationException() throw()
+{
+}
+
+::std::string
+Ice::CollocationOptimizationException::ice_name() const
+{
+    return "Ice::CollocationOptimizationException";
+}
+
+Ice::CollocationOptimizationException*
+Ice::CollocationOptimizationException::ice_clone() const
+{
+    return new CollocationOptimizationException(*this);
+}
+
+void
+Ice::CollocationOptimizationException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::AlreadyRegisteredException::AlreadyRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
+    ::Ice::LocalException(__file, __line),
+    kindOfObject(__ice_kindOfObject),
+    id(__ice_id)
+{
+}
+
+Ice::AlreadyRegisteredException::~AlreadyRegisteredException() throw()
+{
+}
+
+::std::string
+Ice::AlreadyRegisteredException::ice_name() const
+{
+    return "Ice::AlreadyRegisteredException";
+}
+
+Ice::AlreadyRegisteredException*
+Ice::AlreadyRegisteredException::ice_clone() const
+{
+    return new AlreadyRegisteredException(*this);
+}
+
+void
+Ice::AlreadyRegisteredException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::NotRegisteredException::NotRegisteredException(const char* __file, int __line, const ::std::string& __ice_kindOfObject, const ::std::string& __ice_id) :
+    ::Ice::LocalException(__file, __line),
+    kindOfObject(__ice_kindOfObject),
+    id(__ice_id)
+{
+}
+
+Ice::NotRegisteredException::~NotRegisteredException() throw()
+{
+}
+
+::std::string
+Ice::NotRegisteredException::ice_name() const
+{
+    return "Ice::NotRegisteredException";
+}
+
+Ice::NotRegisteredException*
+Ice::NotRegisteredException::ice_clone() const
+{
+    return new NotRegisteredException(*this);
+}
+
+void
+Ice::NotRegisteredException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::TwowayOnlyException::TwowayOnlyException(const char* __file, int __line, const ::std::string& __ice_operation) :
+    ::Ice::LocalException(__file, __line),
+    operation(__ice_operation)
+{
+}
+
+Ice::TwowayOnlyException::~TwowayOnlyException() throw()
+{
+}
+
+::std::string
+Ice::TwowayOnlyException::ice_name() const
+{
+    return "Ice::TwowayOnlyException";
+}
+
+Ice::TwowayOnlyException*
+Ice::TwowayOnlyException::ice_clone() const
+{
+    return new TwowayOnlyException(*this);
+}
+
+void
+Ice::TwowayOnlyException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CloneNotImplementedException::CloneNotImplementedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::CloneNotImplementedException::~CloneNotImplementedException() throw()
+{
+}
+
+::std::string
+Ice::CloneNotImplementedException::ice_name() const
+{
+    return "Ice::CloneNotImplementedException";
+}
+
+Ice::CloneNotImplementedException*
+Ice::CloneNotImplementedException::ice_clone() const
+{
+    return new CloneNotImplementedException(*this);
+}
+
+void
+Ice::CloneNotImplementedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownException::UnknownException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::UnknownException::UnknownException(const char* __file, int __line, const ::std::string& __ice_unknown) :
+    ::Ice::LocalException(__file, __line),
+    unknown(__ice_unknown)
+{
+}
+
+Ice::UnknownException::~UnknownException() throw()
+{
+}
+
+::std::string
+Ice::UnknownException::ice_name() const
+{
+    return "Ice::UnknownException";
+}
+
+Ice::UnknownException*
+Ice::UnknownException::ice_clone() const
+{
+    return new UnknownException(*this);
+}
+
+void
+Ice::UnknownException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line) :
+    ::Ice::UnknownException(__file, __line)
+{
+}
+
+Ice::UnknownLocalException::UnknownLocalException(const char* __file, int __line, const ::std::string& __ice_unknown) :
+    ::Ice::UnknownException(__file, __line, __ice_unknown)
+{
+}
+
+Ice::UnknownLocalException::~UnknownLocalException() throw()
+{
+}
+
+::std::string
+Ice::UnknownLocalException::ice_name() const
+{
+    return "Ice::UnknownLocalException";
+}
+
+Ice::UnknownLocalException*
+Ice::UnknownLocalException::ice_clone() const
+{
+    return new UnknownLocalException(*this);
+}
+
+void
+Ice::UnknownLocalException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownUserException::UnknownUserException(const char* __file, int __line) :
+    ::Ice::UnknownException(__file, __line)
+{
+}
+
+Ice::UnknownUserException::UnknownUserException(const char* __file, int __line, const ::std::string& __ice_unknown) :
+    ::Ice::UnknownException(__file, __line, __ice_unknown)
+{
+}
+
+Ice::UnknownUserException::~UnknownUserException() throw()
+{
+}
+
+::std::string
+Ice::UnknownUserException::ice_name() const
+{
+    return "Ice::UnknownUserException";
+}
+
+Ice::UnknownUserException*
+Ice::UnknownUserException::ice_clone() const
+{
+    return new UnknownUserException(*this);
+}
+
+void
+Ice::UnknownUserException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::VersionMismatchException::VersionMismatchException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::VersionMismatchException::~VersionMismatchException() throw()
+{
+}
+
+::std::string
+Ice::VersionMismatchException::ice_name() const
+{
+    return "Ice::VersionMismatchException";
+}
+
+Ice::VersionMismatchException*
+Ice::VersionMismatchException::ice_clone() const
+{
+    return new VersionMismatchException(*this);
+}
+
+void
+Ice::VersionMismatchException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CommunicatorDestroyedException::CommunicatorDestroyedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::CommunicatorDestroyedException::~CommunicatorDestroyedException() throw()
+{
+}
+
+::std::string
+Ice::CommunicatorDestroyedException::ice_name() const
+{
+    return "Ice::CommunicatorDestroyedException";
+}
+
+Ice::CommunicatorDestroyedException*
+Ice::CommunicatorDestroyedException::ice_clone() const
+{
+    return new CommunicatorDestroyedException(*this);
+}
+
+void
+Ice::CommunicatorDestroyedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::ObjectAdapterDeactivatedException::ObjectAdapterDeactivatedException(const char* __file, int __line, const ::std::string& __ice_name) :
+    ::Ice::LocalException(__file, __line),
+    name(__ice_name)
+{
+}
+
+Ice::ObjectAdapterDeactivatedException::~ObjectAdapterDeactivatedException() throw()
+{
+}
+
+::std::string
+Ice::ObjectAdapterDeactivatedException::ice_name() const
+{
+    return "Ice::ObjectAdapterDeactivatedException";
+}
+
+Ice::ObjectAdapterDeactivatedException*
+Ice::ObjectAdapterDeactivatedException::ice_clone() const
+{
+    return new ObjectAdapterDeactivatedException(*this);
+}
+
+void
+Ice::ObjectAdapterDeactivatedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::ObjectAdapterIdInUseException::ObjectAdapterIdInUseException(const char* __file, int __line, const ::std::string& __ice_id) :
+    ::Ice::LocalException(__file, __line),
+    id(__ice_id)
+{
+}
+
+Ice::ObjectAdapterIdInUseException::~ObjectAdapterIdInUseException() throw()
+{
+}
+
+::std::string
+Ice::ObjectAdapterIdInUseException::ice_name() const
+{
+    return "Ice::ObjectAdapterIdInUseException";
+}
+
+Ice::ObjectAdapterIdInUseException*
+Ice::ObjectAdapterIdInUseException::ice_clone() const
+{
+    return new ObjectAdapterIdInUseException(*this);
+}
+
+void
+Ice::ObjectAdapterIdInUseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::NoEndpointException::NoEndpointException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::NoEndpointException::NoEndpointException(const char* __file, int __line, const ::std::string& __ice_proxy) :
+    ::Ice::LocalException(__file, __line),
+    proxy(__ice_proxy)
+{
+}
+
+Ice::NoEndpointException::~NoEndpointException() throw()
+{
+}
+
+::std::string
+Ice::NoEndpointException::ice_name() const
+{
+    return "Ice::NoEndpointException";
+}
+
+Ice::NoEndpointException*
+Ice::NoEndpointException::ice_clone() const
+{
+    return new NoEndpointException(*this);
+}
+
+void
+Ice::NoEndpointException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::EndpointParseException::EndpointParseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::EndpointParseException::EndpointParseException(const char* __file, int __line, const ::std::string& __ice_str) :
+    ::Ice::LocalException(__file, __line),
+    str(__ice_str)
+{
+}
+
+Ice::EndpointParseException::~EndpointParseException() throw()
+{
+}
+
+::std::string
+Ice::EndpointParseException::ice_name() const
+{
+    return "Ice::EndpointParseException";
+}
+
+Ice::EndpointParseException*
+Ice::EndpointParseException::ice_clone() const
+{
+    return new EndpointParseException(*this);
+}
+
+void
+Ice::EndpointParseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::EndpointSelectionTypeParseException::EndpointSelectionTypeParseException(const char* __file, int __line, const ::std::string& __ice_str) :
+    ::Ice::LocalException(__file, __line),
+    str(__ice_str)
+{
+}
+
+Ice::EndpointSelectionTypeParseException::~EndpointSelectionTypeParseException() throw()
+{
+}
+
+::std::string
+Ice::EndpointSelectionTypeParseException::ice_name() const
+{
+    return "Ice::EndpointSelectionTypeParseException";
+}
+
+Ice::EndpointSelectionTypeParseException*
+Ice::EndpointSelectionTypeParseException::ice_clone() const
+{
+    return new EndpointSelectionTypeParseException(*this);
+}
+
+void
+Ice::EndpointSelectionTypeParseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::VersionParseException::VersionParseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::VersionParseException::VersionParseException(const char* __file, int __line, const ::std::string& __ice_str) :
+    ::Ice::LocalException(__file, __line),
+    str(__ice_str)
+{
+}
+
+Ice::VersionParseException::~VersionParseException() throw()
+{
+}
+
+::std::string
+Ice::VersionParseException::ice_name() const
+{
+    return "Ice::VersionParseException";
+}
+
+Ice::VersionParseException*
+Ice::VersionParseException::ice_clone() const
+{
+    return new VersionParseException(*this);
+}
+
+void
+Ice::VersionParseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::IdentityParseException::IdentityParseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::IdentityParseException::IdentityParseException(const char* __file, int __line, const ::std::string& __ice_str) :
+    ::Ice::LocalException(__file, __line),
+    str(__ice_str)
+{
+}
+
+Ice::IdentityParseException::~IdentityParseException() throw()
+{
+}
+
+::std::string
+Ice::IdentityParseException::ice_name() const
+{
+    return "Ice::IdentityParseException";
+}
+
+Ice::IdentityParseException*
+Ice::IdentityParseException::ice_clone() const
+{
+    return new IdentityParseException(*this);
+}
+
+void
+Ice::IdentityParseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ProxyParseException::ProxyParseException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::ProxyParseException::ProxyParseException(const char* __file, int __line, const ::std::string& __ice_str) :
+    ::Ice::LocalException(__file, __line),
+    str(__ice_str)
+{
+}
+
+Ice::ProxyParseException::~ProxyParseException() throw()
+{
+}
+
+::std::string
+Ice::ProxyParseException::ice_name() const
+{
+    return "Ice::ProxyParseException";
+}
+
+Ice::ProxyParseException*
+Ice::ProxyParseException::ice_clone() const
+{
+    return new ProxyParseException(*this);
+}
+
+void
+Ice::ProxyParseException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::IllegalIdentityException::IllegalIdentityException(const char* __file, int __line, const ::Ice::Identity& __ice_id) :
+    ::Ice::LocalException(__file, __line),
+    id(__ice_id)
+{
+}
+
+Ice::IllegalIdentityException::~IllegalIdentityException() throw()
+{
+}
+
+::std::string
+Ice::IllegalIdentityException::ice_name() const
+{
+    return "Ice::IllegalIdentityException";
+}
+
+Ice::IllegalIdentityException*
+Ice::IllegalIdentityException::ice_clone() const
+{
+    return new IllegalIdentityException(*this);
+}
+
+void
+Ice::IllegalIdentityException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::IllegalServantException::IllegalServantException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::IllegalServantException::IllegalServantException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::LocalException(__file, __line),
+    reason(__ice_reason)
+{
+}
+
+Ice::IllegalServantException::~IllegalServantException() throw()
+{
+}
+
+::std::string
+Ice::IllegalServantException::ice_name() const
+{
+    return "Ice::IllegalServantException";
+}
+
+Ice::IllegalServantException*
+Ice::IllegalServantException::ice_clone() const
+{
+    return new IllegalServantException(*this);
+}
+
+void
+Ice::IllegalServantException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::RequestFailedException::RequestFailedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::RequestFailedException::RequestFailedException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
+    ::Ice::LocalException(__file, __line),
+    id(__ice_id),
+    facet(__ice_facet),
+    operation(__ice_operation)
+{
+}
+
+Ice::RequestFailedException::~RequestFailedException() throw()
+{
+}
+
+::std::string
+Ice::RequestFailedException::ice_name() const
+{
+    return "Ice::RequestFailedException";
+}
+
+Ice::RequestFailedException*
+Ice::RequestFailedException::ice_clone() const
+{
+    return new RequestFailedException(*this);
+}
+
+void
+Ice::RequestFailedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line) :
+    ::Ice::RequestFailedException(__file, __line)
+{
+}
+
+Ice::ObjectNotExistException::ObjectNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
+    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+{
+}
+
+Ice::ObjectNotExistException::~ObjectNotExistException() throw()
+{
+}
+
+::std::string
+Ice::ObjectNotExistException::ice_name() const
+{
+    return "Ice::ObjectNotExistException";
+}
+
+Ice::ObjectNotExistException*
+Ice::ObjectNotExistException::ice_clone() const
+{
+    return new ObjectNotExistException(*this);
+}
+
+void
+Ice::ObjectNotExistException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line) :
+    ::Ice::RequestFailedException(__file, __line)
+{
+}
+
+Ice::FacetNotExistException::FacetNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
+    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+{
+}
+
+Ice::FacetNotExistException::~FacetNotExistException() throw()
+{
+}
+
+::std::string
+Ice::FacetNotExistException::ice_name() const
+{
+    return "Ice::FacetNotExistException";
+}
+
+Ice::FacetNotExistException*
+Ice::FacetNotExistException::ice_clone() const
+{
+    return new FacetNotExistException(*this);
+}
+
+void
+Ice::FacetNotExistException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line) :
+    ::Ice::RequestFailedException(__file, __line)
+{
+}
+
+Ice::OperationNotExistException::OperationNotExistException(const char* __file, int __line, const ::Ice::Identity& __ice_id, const ::std::string& __ice_facet, const ::std::string& __ice_operation) :
+    ::Ice::RequestFailedException(__file, __line, __ice_id, __ice_facet, __ice_operation)
+{
+}
+
+Ice::OperationNotExistException::~OperationNotExistException() throw()
+{
+}
+
+::std::string
+Ice::OperationNotExistException::ice_name() const
+{
+    return "Ice::OperationNotExistException";
+}
+
+Ice::OperationNotExistException*
+Ice::OperationNotExistException::ice_clone() const
+{
+    return new OperationNotExistException(*this);
+}
+
+void
+Ice::OperationNotExistException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::SyscallException::SyscallException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line), 
+    error(0)
+{
+}
+
+Ice::SyscallException::SyscallException(const char* __file, int __line, ::Ice::Int __ice_error) :
+    ::Ice::LocalException(__file, __line),
+    error(__ice_error)
+{
+}
+
+Ice::SyscallException::~SyscallException() throw()
+{
+}
+
+::std::string
+Ice::SyscallException::ice_name() const
+{
+    return "Ice::SyscallException";
+}
+
+Ice::SyscallException*
+Ice::SyscallException::ice_clone() const
+{
+    return new SyscallException(*this);
+}
+
+void
+Ice::SyscallException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::SocketException::SocketException(const char* __file, int __line) :
+    ::Ice::SyscallException(__file, __line)
+{
+}
+
+Ice::SocketException::SocketException(const char* __file, int __line, ::Ice::Int __ice_error) :
+    ::Ice::SyscallException(__file, __line, __ice_error)
+{
+}
+
+Ice::SocketException::~SocketException() throw()
+{
+}
+
+::std::string
+Ice::SocketException::ice_name() const
+{
+    return "Ice::SocketException";
+}
+
+Ice::SocketException*
+Ice::SocketException::ice_clone() const
+{
+    return new SocketException(*this);
+}
+
+void
+Ice::SocketException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::FileException::FileException(const char* __file, int __line) :
+    ::Ice::SyscallException(__file, __line)
+{
+}
+
+Ice::FileException::FileException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_path) :
+    ::Ice::SyscallException(__file, __line, __ice_error),
+    path(__ice_path)
+{
+}
+
+Ice::FileException::~FileException() throw()
+{
+}
+
+::std::string
+Ice::FileException::ice_name() const
+{
+    return "Ice::FileException";
+}
+
+Ice::FileException*
+Ice::FileException::ice_clone() const
+{
+    return new FileException(*this);
+}
+
+void
+Ice::FileException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line) :
+    ::Ice::SocketException(__file, __line)
+{
+}
+
+Ice::ConnectFailedException::ConnectFailedException(const char* __file, int __line, ::Ice::Int __ice_error) :
+    ::Ice::SocketException(__file, __line, __ice_error)
+{
+}
+
+Ice::ConnectFailedException::~ConnectFailedException() throw()
+{
+}
+
+::std::string
+Ice::ConnectFailedException::ice_name() const
+{
+    return "Ice::ConnectFailedException";
+}
+
+Ice::ConnectFailedException*
+Ice::ConnectFailedException::ice_clone() const
+{
+    return new ConnectFailedException(*this);
+}
+
+void
+Ice::ConnectFailedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line) :
+    ::Ice::ConnectFailedException(__file, __line)
+{
+}
+
+Ice::ConnectionRefusedException::ConnectionRefusedException(const char* __file, int __line, ::Ice::Int __ice_error) :
+    ::Ice::ConnectFailedException(__file, __line, __ice_error)
+{
+}
+
+Ice::ConnectionRefusedException::~ConnectionRefusedException() throw()
+{
+}
+
+::std::string
+Ice::ConnectionRefusedException::ice_name() const
+{
+    return "Ice::ConnectionRefusedException";
+}
+
+Ice::ConnectionRefusedException*
+Ice::ConnectionRefusedException::ice_clone() const
+{
+    return new ConnectionRefusedException(*this);
+}
+
+void
+Ice::ConnectionRefusedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line) :
+    ::Ice::SocketException(__file, __line)
+{
+}
+
+Ice::ConnectionLostException::ConnectionLostException(const char* __file, int __line, ::Ice::Int __ice_error) :
+    ::Ice::SocketException(__file, __line, __ice_error)
+{
+}
+
+Ice::ConnectionLostException::~ConnectionLostException() throw()
+{
+}
+
+::std::string
+Ice::ConnectionLostException::ice_name() const
+{
+    return "Ice::ConnectionLostException";
+}
+
+Ice::ConnectionLostException*
+Ice::ConnectionLostException::ice_clone() const
+{
+    return new ConnectionLostException(*this);
+}
+
+void
+Ice::ConnectionLostException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::DNSException::DNSException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line), 
+    error(0)
+{
+}
+
+Ice::DNSException::DNSException(const char* __file, int __line, ::Ice::Int __ice_error, const ::std::string& __ice_host) :
+    ::Ice::LocalException(__file, __line),
+    error(__ice_error),
+    host(__ice_host)
+{
+}
+
+Ice::DNSException::~DNSException() throw()
+{
+}
+
+::std::string
+Ice::DNSException::ice_name() const
+{
+    return "Ice::DNSException";
+}
+
+Ice::DNSException*
+Ice::DNSException::ice_clone() const
+{
+    return new DNSException(*this);
+}
+
+void
+Ice::DNSException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::OperationInterruptedException::OperationInterruptedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::OperationInterruptedException::~OperationInterruptedException() throw()
+{
+}
+
+::std::string
+Ice::OperationInterruptedException::ice_name() const
+{
+    return "Ice::OperationInterruptedException";
+}
+
+Ice::OperationInterruptedException*
+Ice::OperationInterruptedException::ice_clone() const
+{
+    return new OperationInterruptedException(*this);
+}
+
+void
+Ice::OperationInterruptedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::TimeoutException::TimeoutException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::TimeoutException::~TimeoutException() throw()
+{
+}
+
+::std::string
+Ice::TimeoutException::ice_name() const
+{
+    return "Ice::TimeoutException";
+}
+
+Ice::TimeoutException*
+Ice::TimeoutException::ice_clone() const
+{
+    return new TimeoutException(*this);
+}
+
+void
+Ice::TimeoutException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectTimeoutException::ConnectTimeoutException(const char* __file, int __line) :
+    ::Ice::TimeoutException(__file, __line)
+{
+}
+
+Ice::ConnectTimeoutException::~ConnectTimeoutException() throw()
+{
+}
+
+::std::string
+Ice::ConnectTimeoutException::ice_name() const
+{
+    return "Ice::ConnectTimeoutException";
+}
+
+Ice::ConnectTimeoutException*
+Ice::ConnectTimeoutException::ice_clone() const
+{
+    return new ConnectTimeoutException(*this);
+}
+
+void
+Ice::ConnectTimeoutException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CloseTimeoutException::CloseTimeoutException(const char* __file, int __line) :
+    ::Ice::TimeoutException(__file, __line)
+{
+}
+
+Ice::CloseTimeoutException::~CloseTimeoutException() throw()
+{
+}
+
+::std::string
+Ice::CloseTimeoutException::ice_name() const
+{
+    return "Ice::CloseTimeoutException";
+}
+
+Ice::CloseTimeoutException*
+Ice::CloseTimeoutException::ice_clone() const
+{
+    return new CloseTimeoutException(*this);
+}
+
+void
+Ice::CloseTimeoutException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectionTimeoutException::ConnectionTimeoutException(const char* __file, int __line) :
+    ::Ice::TimeoutException(__file, __line)
+{
+}
+
+Ice::ConnectionTimeoutException::~ConnectionTimeoutException() throw()
+{
+}
+
+::std::string
+Ice::ConnectionTimeoutException::ice_name() const
+{
+    return "Ice::ConnectionTimeoutException";
+}
+
+Ice::ConnectionTimeoutException*
+Ice::ConnectionTimeoutException::ice_clone() const
+{
+    return new ConnectionTimeoutException(*this);
+}
+
+void
+Ice::ConnectionTimeoutException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::InvocationTimeoutException::InvocationTimeoutException(const char* __file, int __line) :
+    ::Ice::TimeoutException(__file, __line)
+{
+}
+
+Ice::InvocationTimeoutException::~InvocationTimeoutException() throw()
+{
+}
+
+::std::string
+Ice::InvocationTimeoutException::ice_name() const
+{
+    return "Ice::InvocationTimeoutException";
+}
+
+Ice::InvocationTimeoutException*
+Ice::InvocationTimeoutException::ice_clone() const
+{
+    return new InvocationTimeoutException(*this);
+}
+
+void
+Ice::InvocationTimeoutException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::InvocationCanceledException::InvocationCanceledException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::InvocationCanceledException::~InvocationCanceledException() throw()
+{
+}
+
+::std::string
+Ice::InvocationCanceledException::ice_name() const
+{
+    return "Ice::InvocationCanceledException";
+}
+
+Ice::InvocationCanceledException*
+Ice::InvocationCanceledException::ice_clone() const
+{
+    return new InvocationCanceledException(*this);
+}
+
+void
+Ice::InvocationCanceledException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ProtocolException::ProtocolException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::ProtocolException::ProtocolException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::LocalException(__file, __line),
+    reason(__ice_reason)
+{
+}
+
+Ice::ProtocolException::~ProtocolException() throw()
+{
+}
+
+::std::string
+Ice::ProtocolException::ice_name() const
+{
+    return "Ice::ProtocolException";
+}
+
+Ice::ProtocolException*
+Ice::ProtocolException::ice_clone() const
+{
+    return new ProtocolException(*this);
+}
+
+void
+Ice::ProtocolException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::BadMagicException::BadMagicException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::BadMagicException::BadMagicException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ByteSeq& __ice_badMagic) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason),
+    badMagic(__ice_badMagic)
+{
+}
+
+Ice::BadMagicException::~BadMagicException() throw()
+{
+}
+
+::std::string
+Ice::BadMagicException::ice_name() const
+{
+    return "Ice::BadMagicException";
+}
+
+Ice::BadMagicException*
+Ice::BadMagicException::ice_clone() const
+{
+    return new BadMagicException(*this);
+}
+
+void
+Ice::BadMagicException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::UnsupportedProtocolException::UnsupportedProtocolException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::ProtocolVersion& __ice_bad, const ::Ice::ProtocolVersion& __ice_supported) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason),
+    bad(__ice_bad),
+    supported(__ice_supported)
+{
+}
+
+Ice::UnsupportedProtocolException::~UnsupportedProtocolException() throw()
+{
+}
+
+::std::string
+Ice::UnsupportedProtocolException::ice_name() const
+{
+    return "Ice::UnsupportedProtocolException";
+}
+
+Ice::UnsupportedProtocolException*
+Ice::UnsupportedProtocolException::ice_clone() const
+{
+    return new UnsupportedProtocolException(*this);
+}
+
+void
+Ice::UnsupportedProtocolException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::UnsupportedEncodingException::UnsupportedEncodingException(const char* __file, int __line, const ::std::string& __ice_reason, const ::Ice::EncodingVersion& __ice_bad, const ::Ice::EncodingVersion& __ice_supported) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason),
+    bad(__ice_bad),
+    supported(__ice_supported)
+{
+}
+
+Ice::UnsupportedEncodingException::~UnsupportedEncodingException() throw()
+{
+}
+
+::std::string
+Ice::UnsupportedEncodingException::ice_name() const
+{
+    return "Ice::UnsupportedEncodingException";
+}
+
+Ice::UnsupportedEncodingException*
+Ice::UnsupportedEncodingException::ice_clone() const
+{
+    return new UnsupportedEncodingException(*this);
+}
+
+void
+Ice::UnsupportedEncodingException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::UnknownMessageException::UnknownMessageException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::UnknownMessageException::~UnknownMessageException() throw()
+{
+}
+
+::std::string
+Ice::UnknownMessageException::ice_name() const
+{
+    return "Ice::UnknownMessageException";
+}
+
+Ice::UnknownMessageException*
+Ice::UnknownMessageException::ice_clone() const
+{
+    return new UnknownMessageException(*this);
+}
+
+void
+Ice::UnknownMessageException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::ConnectionNotValidatedException::ConnectionNotValidatedException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::ConnectionNotValidatedException::~ConnectionNotValidatedException() throw()
+{
+}
+
+::std::string
+Ice::ConnectionNotValidatedException::ice_name() const
+{
+    return "Ice::ConnectionNotValidatedException";
+}
+
+Ice::ConnectionNotValidatedException*
+Ice::ConnectionNotValidatedException::ice_clone() const
+{
+    return new ConnectionNotValidatedException(*this);
+}
+
+void
+Ice::ConnectionNotValidatedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::UnknownRequestIdException::UnknownRequestIdException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::UnknownRequestIdException::~UnknownRequestIdException() throw()
+{
+}
+
+::std::string
+Ice::UnknownRequestIdException::ice_name() const
+{
+    return "Ice::UnknownRequestIdException";
+}
+
+Ice::UnknownRequestIdException*
+Ice::UnknownRequestIdException::ice_clone() const
+{
+    return new UnknownRequestIdException(*this);
+}
+
+void
+Ice::UnknownRequestIdException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::UnknownReplyStatusException::UnknownReplyStatusException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::UnknownReplyStatusException::~UnknownReplyStatusException() throw()
+{
+}
+
+::std::string
+Ice::UnknownReplyStatusException::ice_name() const
+{
+    return "Ice::UnknownReplyStatusException";
+}
+
+Ice::UnknownReplyStatusException*
+Ice::UnknownReplyStatusException::ice_clone() const
+{
+    return new UnknownReplyStatusException(*this);
+}
+
+void
+Ice::UnknownReplyStatusException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::CloseConnectionException::CloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::CloseConnectionException::~CloseConnectionException() throw()
+{
+}
+
+::std::string
+Ice::CloseConnectionException::ice_name() const
+{
+    return "Ice::CloseConnectionException";
+}
+
+Ice::CloseConnectionException*
+Ice::CloseConnectionException::ice_clone() const
+{
+    return new CloseConnectionException(*this);
+}
+
+void
+Ice::CloseConnectionException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::ForcedCloseConnectionException::ForcedCloseConnectionException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::ForcedCloseConnectionException::~ForcedCloseConnectionException() throw()
+{
+}
+
+::std::string
+Ice::ForcedCloseConnectionException::ice_name() const
+{
+    return "Ice::ForcedCloseConnectionException";
+}
+
+Ice::ForcedCloseConnectionException*
+Ice::ForcedCloseConnectionException::ice_clone() const
+{
+    return new ForcedCloseConnectionException(*this);
+}
+
+void
+Ice::ForcedCloseConnectionException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::IllegalMessageSizeException::IllegalMessageSizeException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::IllegalMessageSizeException::~IllegalMessageSizeException() throw()
+{
+}
+
+::std::string
+Ice::IllegalMessageSizeException::ice_name() const
+{
+    return "Ice::IllegalMessageSizeException";
+}
+
+Ice::IllegalMessageSizeException*
+Ice::IllegalMessageSizeException::ice_clone() const
+{
+    return new IllegalMessageSizeException(*this);
+}
+
+void
+Ice::IllegalMessageSizeException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::CompressionException::CompressionException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::CompressionException::CompressionException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::CompressionException::~CompressionException() throw()
+{
+}
+
+::std::string
+Ice::CompressionException::ice_name() const
+{
+    return "Ice::CompressionException";
+}
+
+Ice::CompressionException*
+Ice::CompressionException::ice_clone() const
+{
+    return new CompressionException(*this);
+}
+
+void
+Ice::CompressionException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::DatagramLimitException::DatagramLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::DatagramLimitException::~DatagramLimitException() throw()
+{
+}
+
+::std::string
+Ice::DatagramLimitException::ice_name() const
+{
+    return "Ice::DatagramLimitException";
+}
+
+Ice::DatagramLimitException*
+Ice::DatagramLimitException::ice_clone() const
+{
+    return new DatagramLimitException(*this);
+}
+
+void
+Ice::DatagramLimitException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::MarshalException::MarshalException(const char* __file, int __line) :
+    ::Ice::ProtocolException(__file, __line)
+{
+}
+
+Ice::MarshalException::MarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::ProtocolException(__file, __line, __ice_reason)
+{
+}
+
+Ice::MarshalException::~MarshalException() throw()
+{
+}
+
+::std::string
+Ice::MarshalException::ice_name() const
+{
+    return "Ice::MarshalException";
+}
+
+Ice::MarshalException*
+Ice::MarshalException::ice_clone() const
+{
+    return new MarshalException(*this);
+}
+
+void
+Ice::MarshalException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::ProxyUnmarshalException::ProxyUnmarshalException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::MarshalException(__file, __line, __ice_reason)
+{
+}
+
+Ice::ProxyUnmarshalException::~ProxyUnmarshalException() throw()
+{
+}
+
+::std::string
+Ice::ProxyUnmarshalException::ice_name() const
+{
+    return "Ice::ProxyUnmarshalException";
+}
+
+Ice::ProxyUnmarshalException*
+Ice::ProxyUnmarshalException::ice_clone() const
+{
+    return new ProxyUnmarshalException(*this);
+}
+
+void
+Ice::ProxyUnmarshalException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::UnmarshalOutOfBoundsException::UnmarshalOutOfBoundsException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::MarshalException(__file, __line, __ice_reason)
+{
+}
+
+Ice::UnmarshalOutOfBoundsException::~UnmarshalOutOfBoundsException() throw()
+{
+}
+
+::std::string
+Ice::UnmarshalOutOfBoundsException::ice_name() const
+{
+    return "Ice::UnmarshalOutOfBoundsException";
+}
+
+Ice::UnmarshalOutOfBoundsException*
+Ice::UnmarshalOutOfBoundsException::ice_clone() const
+{
+    return new UnmarshalOutOfBoundsException(*this);
+}
+
+void
+Ice::UnmarshalOutOfBoundsException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::NoObjectFactoryException::NoObjectFactoryException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type) :
+    ::Ice::MarshalException(__file, __line, __ice_reason),
+    type(__ice_type)
+{
+}
+
+Ice::NoObjectFactoryException::~NoObjectFactoryException() throw()
+{
+}
+
+::std::string
+Ice::NoObjectFactoryException::ice_name() const
+{
+    return "Ice::NoObjectFactoryException";
+}
+
+Ice::NoObjectFactoryException*
+Ice::NoObjectFactoryException::ice_clone() const
+{
+    return new NoObjectFactoryException(*this);
+}
+
+void
+Ice::NoObjectFactoryException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::UnexpectedObjectException::UnexpectedObjectException(const char* __file, int __line, const ::std::string& __ice_reason, const ::std::string& __ice_type, const ::std::string& __ice_expectedType) :
+    ::Ice::MarshalException(__file, __line, __ice_reason),
+    type(__ice_type),
+    expectedType(__ice_expectedType)
+{
+}
+
+Ice::UnexpectedObjectException::~UnexpectedObjectException() throw()
+{
+}
+
+::std::string
+Ice::UnexpectedObjectException::ice_name() const
+{
+    return "Ice::UnexpectedObjectException";
+}
+
+Ice::UnexpectedObjectException*
+Ice::UnexpectedObjectException::ice_clone() const
+{
+    return new UnexpectedObjectException(*this);
+}
+
+void
+Ice::UnexpectedObjectException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::MemoryLimitException::MemoryLimitException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::MarshalException(__file, __line, __ice_reason)
+{
+}
+
+Ice::MemoryLimitException::~MemoryLimitException() throw()
+{
+}
+
+::std::string
+Ice::MemoryLimitException::ice_name() const
+{
+    return "Ice::MemoryLimitException";
+}
+
+Ice::MemoryLimitException*
+Ice::MemoryLimitException::ice_clone() const
+{
+    return new MemoryLimitException(*this);
+}
+
+void
+Ice::MemoryLimitException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::StringConversionException::StringConversionException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::StringConversionException::StringConversionException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::MarshalException(__file, __line, __ice_reason)
+{
+}
+
+Ice::StringConversionException::~StringConversionException() throw()
+{
+}
+
+::std::string
+Ice::StringConversionException::ice_name() const
+{
+    return "Ice::StringConversionException";
+}
+
+Ice::StringConversionException*
+Ice::StringConversionException::ice_clone() const
+{
+    return new StringConversionException(*this);
+}
+
+void
+Ice::StringConversionException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::EncapsulationException::EncapsulationException(const char* __file, int __line) :
+    ::Ice::MarshalException(__file, __line)
+{
+}
+
+Ice::EncapsulationException::EncapsulationException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::MarshalException(__file, __line, __ice_reason)
+{
+}
+
+Ice::EncapsulationException::~EncapsulationException() throw()
+{
+}
+
+::std::string
+Ice::EncapsulationException::ice_name() const
+{
+    return "Ice::EncapsulationException";
+}
+
+Ice::EncapsulationException*
+Ice::EncapsulationException::ice_clone() const
+{
+    return new EncapsulationException(*this);
+}
+
+void
+Ice::EncapsulationException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::FeatureNotSupportedException::FeatureNotSupportedException(const char* __file, int __line, const ::std::string& __ice_unsupportedFeature) :
+    ::Ice::LocalException(__file, __line),
+    unsupportedFeature(__ice_unsupportedFeature)
+{
+}
+
+Ice::FeatureNotSupportedException::~FeatureNotSupportedException() throw()
+{
+}
+
+::std::string
+Ice::FeatureNotSupportedException::ice_name() const
+{
+    return "Ice::FeatureNotSupportedException";
+}
+
+Ice::FeatureNotSupportedException*
+Ice::FeatureNotSupportedException::ice_clone() const
+{
+    return new FeatureNotSupportedException(*this);
+}
+
+void
+Ice::FeatureNotSupportedException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::SecurityException::SecurityException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::SecurityException::SecurityException(const char* __file, int __line, const ::std::string& __ice_reason) :
+    ::Ice::LocalException(__file, __line),
+    reason(__ice_reason)
+{
+}
+
+Ice::SecurityException::~SecurityException() throw()
+{
+}
+
+::std::string
+Ice::SecurityException::ice_name() const
+{
+    return "Ice::SecurityException";
+}
+
+Ice::SecurityException*
+Ice::SecurityException::ice_clone() const
+{
+    return new SecurityException(*this);
+}
+
+void
+Ice::SecurityException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::FixedProxyException::FixedProxyException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::FixedProxyException::~FixedProxyException() throw()
+{
+}
+
+::std::string
+Ice::FixedProxyException::ice_name() const
+{
+    return "Ice::FixedProxyException";
+}
+
+Ice::FixedProxyException*
+Ice::FixedProxyException::ice_clone() const
+{
+    return new FixedProxyException(*this);
+}
+
+void
+Ice::FixedProxyException::ice_throw() const
+{
+    throw *this;
+}
+
+Ice::ResponseSentException::ResponseSentException(const char* __file, int __line) :
+    ::Ice::LocalException(__file, __line)
+{
+}
+
+Ice::ResponseSentException::~ResponseSentException() throw()
+{
+}
+
+::std::string
+Ice::ResponseSentException::ice_name() const
+{
+    return "Ice::ResponseSentException";
+}
+
+Ice::ResponseSentException*
+Ice::ResponseSentException::ice_clone() const
+{
+    return new ResponseSentException(*this);
+}
+
+void
+Ice::ResponseSentException::ice_throw() const
+{
+    throw *this;
+}
+
+namespace Ice
+{
+}