zeroc-ice 3.6.5 → 3.7.4

data/lib/Ice.rb

@@ -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.
-#
-# **********************************************************************
 
 require 'IceRuby'
 require 'thread'
@@ -43,11 +38,10 @@ module Ice
         end
 
         if RUBY_PLATFORM =~ /linux/i
-            iceVer = Ice::stringVersion
             #
-            # Check the default RPM location.
+            # Check the default Linux location.
             #
-            dir = File::join("/", "usr", "share", "Ice-" + iceVer, "slice")
+            dir = File::join("/", "usr", "share", "ice", "slice")
             if File::exists?(dir)
                 return dir
             end
@@ -61,6 +55,10 @@ module Ice
     #
     class Exception < ::StandardError
         def ice_name
+            to_s[2..-1]
+        end
+
+        def ice_id
             to_s
         end
 
@@ -76,53 +74,94 @@ module Ice
     end
 
     #
-    # Object.
+    # Ice::Object
     #
-    T_Object = Ice.__declareClass('::Ice::Object')
+    T_Value = Ice.__declareClass('::Ice::Object')
     T_ObjectPrx = Ice.__declareProxy('::Ice::Object')
 
-    module Object_mixin
-        def ice_isA(id, current=nil)
-            return ice_ids().include?(id)
+    #
+    # Provide some common functionality for structs
+    #
+    module Inspect_mixin
+        def inspect
+            ::Ice::__stringify(self, self.class::ICE_TYPE)
         end
+    end
+
+    #
+    # Provide some common functionality for proxy classes
+    #
+    module Proxy_mixin
+        module ClassMethods
+            def inspect
+                ::Ice::__stringify(self, self.class::ICE_TYPE)
+            end
+
+            def ice_staticId()
+                self::ICE_ID
+            end
+
+            def checkedCast(proxy, facetOrContext=nil, context=nil)
+                ice_checkedCast(proxy, self::ICE_ID, facetOrContext, context)
+            end
 
-        def ice_ping(current=nil)
+            def uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
         end
 
-        attr_accessor :_ice_slicedData  # Only used for instances of preserved classes.
+        def self.included(base)
+            base.extend(ClassMethods)
+        end
     end
 
-    class Object
-        include Object_mixin
+    #
+    # Base class for Value types
+    #
+    class Value
+        def inspect
+            ::Ice::__stringify(self, self.class::ICE_TYPE)
+        end
+
+        def ice_id()
+            self.class::ICE_ID
+        end
 
-        def Object.ice_staticId()
-            '::Ice::Object'
+        def Value.ice_staticId()
+            self::ICE_ID
         end
+
+        def ice_getSlicedData()
+            return _ice_slicedData
+        end
+
+        attr_accessor :_ice_slicedData  # Only used for instances of preserved classes.
     end
 
-    T_Object.defineClass(nil, -1, true, false, nil, [], [])
-    Object_mixin::ICE_TYPE = T_Object
+    T_Value.defineClass(Value, -1, false, false, nil, [])
 
-    T_ObjectPrx.defineProxy(ObjectPrx, T_Object)
-    ObjectPrx::ICE_TYPE = T_ObjectPrx
+    T_ObjectPrx.defineProxy(ObjectPrx, nil, [])
 
-    #
-    # LocalObject.
-    #
-    T_LocalObject = Ice.__declareLocalClass('::Ice::LocalObject')
-    T_LocalObject.defineClass(nil, -1, true, false, nil, [], [])
+    class InterfaceByValue < Value
+        def initialize(id)
+            @id = id
+        end
+
+        def ice_id
+            @id
+        end
+    end
 
     #
-    # UnknownSlicedObject.
+    # UnknownSlicedValue.
     #
-    class UnknownSlicedObject
-        include ::Ice::Object_mixin
-
-        attr_accessor :unknownTypeId
+    class UnknownSlicedValue < Value
+        def ice_id
+            return @unknownTypeId
+        end
     end
-    T_UnknownSlicedObject = Ice.__declareClass('::Ice::UnknownSlicedObject')
-    T_UnknownSlicedObject.defineClass(UnknownSlicedObject, -1, false, true, nil, [], [])
-    UnknownSlicedObject::ICE_TYPE = T_UnknownSlicedObject
+    T_UnknownSlicedValue = Ice.__declareClass('::Ice::UnknownSlicedValue')
+    T_UnknownSlicedValue.defineClass(UnknownSlicedValue, -1, true, false, T_Value, [])
 
     #
     # InitializationData.
@@ -147,7 +186,7 @@ module Ice
     # SliceInfo
     #
     class SliceInfo
-        attr_accessor :typeId, :bytes, :objects
+        attr_accessor :typeId, :compactId, :bytes, :instances, :hasOptionalMembers, :isLastSlice
     end
 
     class FormatType
@@ -209,11 +248,13 @@ end
 #
 require 'Ice/BuiltinSequences.rb'
 require 'Ice/Current.rb'
+require 'Ice/Communicator.rb'
 require 'Ice/EndpointTypes.rb'
 require 'Ice/LocalException.rb'
 require 'Ice/Locator.rb'
 require 'Ice/Logger.rb'
 require 'Ice/ObjectFactory.rb'
+require 'Ice/ValueFactory.rb'
 require 'Ice/Process.rb'
 require 'Ice/Router.rb'
 require 'Ice/Connection.rb'
@@ -253,7 +294,7 @@ module Ice
             @mutex = Mutex.new
             @queue = Array.new
             @callback = nil
-            
+
             @read, @write = IO.pipe
 
             #
@@ -315,7 +356,6 @@ module Ice
             }
         end
 
- 
         @@_self = nil
     end
 
@@ -326,7 +366,7 @@ module Ice
         def initialize(signalPolicy=HandleSignals)
             @@_signalPolicy = signalPolicy
         end
-        
+
         def main(args, configFile=nil, initData=nil)
             if @@_communicator
                 Ice::getProcessLogger().error($0 + ": only one instance of the Application class can be used")
@@ -400,13 +440,7 @@ module Ice
             }
 
             if @@_communicator
-                begin
-                    @@_communicator.destroy()
-                rescue => ex
-                    Ice::getProcessLogger().error($!.inspect + "\n" + ex.backtrace.join("\n"))
-                    status = 1
-                end
-
+                @@_communicator.destroy()
                 @@_communicator = nil
             end
 
@@ -546,11 +580,8 @@ module Ice
                 @@_destroyed = true
             }
 
-            begin
-                @@_communicator.destroy()
-            rescue => ex
-                Ice::getProcessLogger().error($!.inspect + "\n" + @@_appName + " (while destroying in response to signal " + sig + "):\n" + ex.backtrace.join("\n"))
-            end
+            @@_communicator.destroy()
+
             @@_mutex.synchronize {
                 @@_callbackInProcess = false
                 @@_condVar.signal
@@ -640,8 +671,3 @@ module Ice
     Encoding_1_0 = EncodingVersion.new(1, 0)
     Encoding_1_1 = EncodingVersion.new(1, 1)
 end
-
-Ice::Object_mixin::OP_ice_isA = ::Ice::__defineOperation('ice_isA', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [[::Ice::T_string, false, 0]], [], [::Ice::T_bool, false, 0], [])
-Ice::Object_mixin::OP_ice_ping = ::Ice::__defineOperation('ice_ping', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], nil, [])
-Ice::Object_mixin::OP_ice_ids = ::Ice::__defineOperation('ice_ids', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_StringSeq, false, 0], [])
-Ice::Object_mixin::OP_ice_id = ::Ice::__defineOperation('ice_id', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Nonmutating, false, nil, [], [], [::Ice::T_string, false, 0], [])

data/lib/Ice/BuiltinSequences.rb

@@ -1,14 +1,9 @@
 # encoding: utf-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>
 #
@@ -56,7 +51,7 @@ module ::Ice
     end
 
     if not defined?(::Ice::T_ObjectSeq)
-        T_ObjectSeq = ::Ice::__defineSequence('::Ice::ObjectSeq', ::Ice::T_Object)
+        T_ObjectSeq = ::Ice::__defineSequence('::Ice::ObjectSeq', ::Ice::T_Value)
     end
 
     if not defined?(::Ice::T_ObjectProxySeq)

data/lib/Ice/Communicator.rb

@@ -1,14 +1,9 @@
 # encoding: utf-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,72 +18,70 @@ require 'Ice'
 require 'Ice/LoggerF.rb'
 require 'Ice/InstrumentationF.rb'
 require 'Ice/ObjectAdapterF.rb'
-require 'Ice/ObjectFactoryF.rb'
-require 'Ice/RouterF.rb'
-require 'Ice/LocatorF.rb'
+require 'Ice/ObjectFactory.rb'
+require 'Ice/ValueFactory.rb'
+require 'Ice/Router.rb'
+require 'Ice/Locator.rb'
 require 'Ice/PluginF.rb'
 require 'Ice/ImplicitContextF.rb'
 require 'Ice/Current.rb'
 require 'Ice/Properties.rb'
 require 'Ice/FacetMap.rb'
+require 'Ice/Connection.rb'
 
 module ::Ice
 
-    if not defined?(::Ice::Communicator_mixin)
-        module Communicator_mixin
-
-            #
-            # Operation signatures.
-            #
-            # def destroy()
-            # def shutdown()
-            # def waitForShutdown()
-            # def isShutdown()
-            # def stringToProxy(str)
-            # def proxyToString(obj)
-            # def propertyToProxy(property)
-            # def proxyToProperty(proxy, property)
-            # def stringToIdentity(str)
-            # def identityToString(ident)
-            # def createObjectAdapter(name)
-            # def createObjectAdapterWithEndpoints(name, endpoints)
-            # def createObjectAdapterWithRouter(name, rtr)
-            # def addObjectFactory(factory, id)
-            # def findObjectFactory(id)
-            # def getImplicitContext()
-            # def getProperties()
-            # def getLogger()
-            # def getObserver()
-            # def getDefaultRouter()
-            # def setDefaultRouter(rtr)
-            # def getDefaultLocator()
-            # def setDefaultLocator(loc)
-            # def getPluginManager()
-            # def flushBatchRequests()
-            # def createAdmin(adminAdapter, adminId)
-            # def getAdmin()
-            # def addAdminFacet(servant, facet)
-            # def removeAdminFacet(facet)
-            # def findAdminFacet(facet)
-            # def findAllAdminFacets()
-
-            def inspect
-                ::Ice::__stringify(self, T_Communicator)
+    if not defined?(::Ice::T_Communicator)
+        T_Communicator = ::Ice::__declareLocalClass('::Ice::Communicator')
+    end
+
+    if not defined?(::Ice::ToStringMode)
+        class ToStringMode
+            include Comparable
+
+            def initialize(name, value)
+                @name = name
+                @value = value
             end
-        end
-        class Communicator
-            include Communicator_mixin
-            
-            def Communicator.ice_staticId()
-                '::Ice::Communicator'
+
+            def ToStringMode.from_int(val)
+                @@_enumerators[val]
+            end
+
+            def to_s
+                @name
+            end
+
+            def to_i
+                @value
+            end
+
+            def <=>(other)
+                other.is_a?(ToStringMode) or raise ArgumentError, "value must be a ToStringMode"
+                @value <=> other.to_i
+            end
+
+            def hash
+                @value.hash
+            end
+
+            def ToStringMode.each(&block)
+                @@_enumerators.each_value(&block)
+            end
+
+            Unicode = ToStringMode.new("Unicode", 0)
+            ASCII = ToStringMode.new("ASCII", 1)
+            Compat = ToStringMode.new("Compat", 2)
+
+            @@_enumerators = {0=>Unicode, 1=>ASCII, 2=>Compat}
+
+            def ToStringMode._enumerators
+                @@_enumerators
             end
-        end
 
-        if not defined?(::Ice::T_Communicator)
-            T_Communicator = ::Ice::__declareLocalClass('::Ice::Communicator')
+            private_class_method :new
         end
 
-        T_Communicator.defineClass(Communicator, -1, true, false, nil, [], [])
-        Communicator_mixin::ICE_TYPE = T_Communicator
+        T_ToStringMode = ::Ice::__defineEnum('::Ice::ToStringMode', ToStringMode, ToStringMode::_enumerators)
     end
 end

data/lib/Ice/CommunicatorF.rb

@@ -1,14 +1,9 @@
 # encoding: utf-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>
 #

data/lib/Ice/Connection.rb

@@ -1,14 +1,9 @@
 # encoding: utf-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>
 #
@@ -26,76 +21,94 @@ require 'Ice/Endpoint.rb'
 
 module ::Ice
 
-    if not defined?(::Ice::ConnectionInfo_mixin)
-        module ConnectionInfo_mixin
+    if not defined?(::Ice::CompressBatch)
+        class CompressBatch
+            include Comparable
+
+            def initialize(name, value)
+                @name = name
+                @value = value
+            end
+
+            def CompressBatch.from_int(val)
+                @@_enumerators[val]
+            end
+
+            def to_s
+                @name
+            end
 
-            def inspect
-                ::Ice::__stringify(self, T_ConnectionInfo)
+            def to_i
+                @value
             end
 
-            attr_accessor :incoming, :adapterName, :connectionId, :rcvSize, :sndSize
+            def <=>(other)
+                other.is_a?(CompressBatch) or raise ArgumentError, "value must be a CompressBatch"
+                @value <=> other.to_i
+            end
+
+            def hash
+                @value.hash
+            end
+
+            def CompressBatch.each(&block)
+                @@_enumerators.each_value(&block)
+            end
+
+            Yes = CompressBatch.new("Yes", 0)
+            No = CompressBatch.new("No", 1)
+            BasedOnProxy = CompressBatch.new("BasedOnProxy", 2)
+
+            @@_enumerators = {0=>Yes, 1=>No, 2=>BasedOnProxy}
+
+            def CompressBatch._enumerators
+                @@_enumerators
+            end
+
+            private_class_method :new
+        end
+
+        T_CompressBatch = ::Ice::__defineEnum('::Ice::CompressBatch', CompressBatch, CompressBatch::_enumerators)
+    end
+
+    if not defined?(::Ice::ConnectionInfo_Mixin)
+
+        module ::Ice::ConnectionInfo_Mixin
         end
         class ConnectionInfo
-            include ConnectionInfo_mixin
-            
-            def ConnectionInfo.ice_staticId()
-                '::Ice::ConnectionInfo'
-            end
 
-            def initialize(incoming=false, adapterName='', connectionId='', rcvSize=0, sndSize=0)
+            def initialize(underlying=nil, incoming=false, adapterName='', connectionId='')
+                @underlying = underlying
                 @incoming = incoming
                 @adapterName = adapterName
                 @connectionId = connectionId
-                @rcvSize = rcvSize
-                @sndSize = sndSize
             end
+
+            attr_accessor :underlying, :incoming, :adapterName, :connectionId
         end
 
         if not defined?(::Ice::T_ConnectionInfo)
             T_ConnectionInfo = ::Ice::__declareLocalClass('::Ice::ConnectionInfo')
         end
 
-        T_ConnectionInfo.defineClass(ConnectionInfo, -1, false, false, nil, [], [
+        T_ConnectionInfo.defineClass(ConnectionInfo, -1, false, false, nil, [
+            ['underlying', ::Ice::T_ConnectionInfo, false, 0],
             ['incoming', ::Ice::T_bool, false, 0],
             ['adapterName', ::Ice::T_string, false, 0],
-            ['connectionId', ::Ice::T_string, false, 0],
-            ['rcvSize', ::Ice::T_int, false, 0],
-            ['sndSize', ::Ice::T_int, false, 0]
+            ['connectionId', ::Ice::T_string, false, 0]
         ])
-        ConnectionInfo_mixin::ICE_TYPE = T_ConnectionInfo
     end
 
     if not defined?(::Ice::T_Connection)
         T_Connection = ::Ice::__declareLocalClass('::Ice::Connection')
     end
 
-    if not defined?(::Ice::ConnectionCallback_mixin)
-        module ConnectionCallback_mixin
-
-            #
-            # Operation signatures.
-            #
-            # def heartbeat(con)
-            # def closed(con)
-
-            def inspect
-                ::Ice::__stringify(self, T_ConnectionCallback)
-            end
-        end
-        class ConnectionCallback
-            include ConnectionCallback_mixin
-            
-            def ConnectionCallback.ice_staticId()
-                '::Ice::ConnectionCallback'
-            end
-        end
-
-        if not defined?(::Ice::T_ConnectionCallback)
-            T_ConnectionCallback = ::Ice::__declareLocalClass('::Ice::ConnectionCallback')
-        end
+    if not defined?(::Ice::T_CloseCallback)
+        T_CloseCallback = ::Ice::__declareLocalClass('::Ice::CloseCallback')
+    end
 
-        T_ConnectionCallback.defineClass(ConnectionCallback, -1, true, false, nil, [], [])
-        ConnectionCallback_mixin::ICE_TYPE = T_ConnectionCallback
+    if not defined?(::Ice::T_HeartbeatCallback)
+        T_HeartbeatCallback = ::Ice::__declareLocalClass('::Ice::HeartbeatCallback')
     end
 
     if not defined?(::Ice::ACMClose)
@@ -128,10 +141,6 @@ module ::Ice
                 @value.hash
             end
 
-            def inspect
-                @name + "(#{@value})"
-            end
-
             def ACMClose.each(&block)
                 @@_enumerators.each_value(&block)
             end
@@ -184,20 +193,16 @@ module ::Ice
                 @value.hash
             end
 
-            def inspect
-                @name + "(#{@value})"
-            end
-
             def ACMHeartbeat.each(&block)
                 @@_enumerators.each_value(&block)
             end
 
             HeartbeatOff = ACMHeartbeat.new("HeartbeatOff", 0)
-            HeartbeatOnInvocation = ACMHeartbeat.new("HeartbeatOnInvocation", 1)
+            HeartbeatOnDispatch = ACMHeartbeat.new("HeartbeatOnDispatch", 1)
             HeartbeatOnIdle = ACMHeartbeat.new("HeartbeatOnIdle", 2)
             HeartbeatAlways = ACMHeartbeat.new("HeartbeatAlways", 3)
 
-            @@_enumerators = {0=>HeartbeatOff, 1=>HeartbeatOnInvocation, 2=>HeartbeatOnIdle, 3=>HeartbeatAlways}
+            @@_enumerators = {0=>HeartbeatOff, 1=>HeartbeatOnDispatch, 2=>HeartbeatOnIdle, 3=>HeartbeatAlways}
 
             def ACMHeartbeat._enumerators
                 @@_enumerators
@@ -211,6 +216,7 @@ module ::Ice
 
     if not defined?(::Ice::ACM)
         class ACM
+            include ::Ice::Inspect_mixin
             def initialize(timeout=0, close=::Ice::ACMClose::CloseOff, heartbeat=::Ice::ACMHeartbeat::HeartbeatOff)
                 @timeout = timeout
                 @close = close
@@ -237,10 +243,6 @@ module ::Ice
                 return other.class == self.class && other == self
             end
 
-            def inspect
-                ::Ice::__stringify(self, T_ACM)
-            end
-
             attr_accessor :timeout, :close, :heartbeat
         end
 
@@ -251,177 +253,161 @@ module ::Ice
         ])
     end
 
-    if not defined?(::Ice::Connection_mixin)
-        module Connection_mixin
-
-            #
-            # Operation signatures.
-            #
-            # def close(force)
-            # def createProxy(id)
-            # def setAdapter(adapter)
-            # def getAdapter()
-            # def getEndpoint()
-            # def flushBatchRequests()
-            # def setCallback(callback)
-            # def setACM(timeout, close, heartbeat)
-            # def getACM()
-            # def type()
-            # def timeout()
-            # def toString()
-            # def getInfo()
-            # def setBufferSize(rcvSize, sndSize)
-
-            def inspect
-                ::Ice::__stringify(self, T_Connection)
+    if not defined?(::Ice::ConnectionClose)
+        class ConnectionClose
+            include Comparable
+
+            def initialize(name, value)
+                @name = name
+                @value = value
             end
-        end
-        class Connection
-            include Connection_mixin
-            
-            def Connection.ice_staticId()
-                '::Ice::Connection'
+
+            def ConnectionClose.from_int(val)
+                @@_enumerators[val]
             end
-        end
 
-        if not defined?(::Ice::T_Connection)
-            T_Connection = ::Ice::__declareLocalClass('::Ice::Connection')
-        end
+            def to_s
+                @name
+            end
 
-        T_Connection.defineClass(Connection, -1, true, false, nil, [], [])
-        Connection_mixin::ICE_TYPE = T_Connection
-    end
+            def to_i
+                @value
+            end
 
-    if not defined?(::Ice::IPConnectionInfo_mixin)
-        module IPConnectionInfo_mixin
+            def <=>(other)
+                other.is_a?(ConnectionClose) or raise ArgumentError, "value must be a ConnectionClose"
+                @value <=> other.to_i
+            end
 
-            def inspect
-                ::Ice::__stringify(self, T_IPConnectionInfo)
+            def hash
+                @value.hash
             end
 
-            attr_accessor :localAddress, :localPort, :remoteAddress, :remotePort
-        end
-        class IPConnectionInfo
-            include IPConnectionInfo_mixin
-            
-            def IPConnectionInfo.ice_staticId()
-                '::Ice::IPConnectionInfo'
+            def ConnectionClose.each(&block)
+                @@_enumerators.each_value(&block)
             end
 
-            def initialize(incoming=false, adapterName='', connectionId='', rcvSize=0, sndSize=0, localAddress="", localPort=-1, remoteAddress="", remotePort=-1)
-                super(incoming, adapterName, connectionId, rcvSize, sndSize)
+            Forcefully = ConnectionClose.new("Forcefully", 0)
+            Gracefully = ConnectionClose.new("Gracefully", 1)
+            GracefullyWithWait = ConnectionClose.new("GracefullyWithWait", 2)
+
+            @@_enumerators = {0=>Forcefully, 1=>Gracefully, 2=>GracefullyWithWait}
+
+            def ConnectionClose._enumerators
+                @@_enumerators
+            end
+
+            private_class_method :new
+        end
+
+        T_ConnectionClose = ::Ice::__defineEnum('::Ice::ConnectionClose', ConnectionClose, ConnectionClose::_enumerators)
+    end
+
+    if not defined?(::Ice::IPConnectionInfo_Mixin)
+
+        module ::Ice::IPConnectionInfo_Mixin
+        end
+        class IPConnectionInfo < ::Ice::ConnectionInfo
+
+            def initialize(underlying=nil, incoming=false, adapterName='', connectionId='', localAddress="", localPort=-1, remoteAddress="", remotePort=-1)
+                super(underlying, incoming, adapterName, connectionId)
                 @localAddress = localAddress
                 @localPort = localPort
                 @remoteAddress = remoteAddress
                 @remotePort = remotePort
             end
+
+            attr_accessor :localAddress, :localPort, :remoteAddress, :remotePort
         end
 
         if not defined?(::Ice::T_IPConnectionInfo)
             T_IPConnectionInfo = ::Ice::__declareLocalClass('::Ice::IPConnectionInfo')
         end
 
-        T_IPConnectionInfo.defineClass(IPConnectionInfo, -1, false, false, nil, [], [
+        T_IPConnectionInfo.defineClass(IPConnectionInfo, -1, false, false, ::Ice::T_ConnectionInfo, [
             ['localAddress', ::Ice::T_string, false, 0],
             ['localPort', ::Ice::T_int, false, 0],
             ['remoteAddress', ::Ice::T_string, false, 0],
             ['remotePort', ::Ice::T_int, false, 0]
         ])
-        IPConnectionInfo_mixin::ICE_TYPE = T_IPConnectionInfo
     end
 
-    if not defined?(::Ice::TCPConnectionInfo_mixin)
-        module TCPConnectionInfo_mixin
+    if not defined?(::Ice::TCPConnectionInfo_Mixin)
 
-            def inspect
-                ::Ice::__stringify(self, T_TCPConnectionInfo)
-            end
+        module ::Ice::TCPConnectionInfo_Mixin
         end
-        class TCPConnectionInfo
-            include TCPConnectionInfo_mixin
-            
-            def TCPConnectionInfo.ice_staticId()
-                '::Ice::TCPConnectionInfo'
-            end
+        class TCPConnectionInfo < ::Ice::IPConnectionInfo
 
-            def initialize(incoming=false, adapterName='', connectionId='', rcvSize=0, sndSize=0, localAddress="", localPort=-1, remoteAddress="", remotePort=-1)
-                super(incoming, adapterName, connectionId, rcvSize, sndSize, localAddress, localPort, remoteAddress, remotePort)
+            def initialize(underlying=nil, incoming=false, adapterName='', connectionId='', localAddress="", localPort=-1, remoteAddress="", remotePort=-1, rcvSize=0, sndSize=0)
+                super(underlying, incoming, adapterName, connectionId, localAddress, localPort, remoteAddress, remotePort)
+                @rcvSize = rcvSize
+                @sndSize = sndSize
             end
+
+            attr_accessor :rcvSize, :sndSize
         end
 
         if not defined?(::Ice::T_TCPConnectionInfo)
             T_TCPConnectionInfo = ::Ice::__declareLocalClass('::Ice::TCPConnectionInfo')
         end
 
-        T_TCPConnectionInfo.defineClass(TCPConnectionInfo, -1, false, false, nil, [], [])
-        TCPConnectionInfo_mixin::ICE_TYPE = T_TCPConnectionInfo
+        T_TCPConnectionInfo.defineClass(TCPConnectionInfo, -1, false, false, ::Ice::T_IPConnectionInfo, [
+            ['rcvSize', ::Ice::T_int, false, 0],
+            ['sndSize', ::Ice::T_int, false, 0]
+        ])
     end
 
-    if not defined?(::Ice::UDPConnectionInfo_mixin)
-        module UDPConnectionInfo_mixin
-
-            def inspect
-                ::Ice::__stringify(self, T_UDPConnectionInfo)
-            end
+    if not defined?(::Ice::UDPConnectionInfo_Mixin)
 
-            attr_accessor :mcastAddress, :mcastPort
+        module ::Ice::UDPConnectionInfo_Mixin
         end
-        class UDPConnectionInfo
-            include UDPConnectionInfo_mixin
-            
-            def UDPConnectionInfo.ice_staticId()
-                '::Ice::UDPConnectionInfo'
-            end
+        class UDPConnectionInfo < ::Ice::IPConnectionInfo
 
-            def initialize(incoming=false, adapterName='', connectionId='', rcvSize=0, sndSize=0, localAddress="", localPort=-1, remoteAddress="", remotePort=-1, mcastAddress='', mcastPort=-1)
-                super(incoming, adapterName, connectionId, rcvSize, sndSize, localAddress, localPort, remoteAddress, remotePort)
+            def initialize(underlying=nil, incoming=false, adapterName='', connectionId='', localAddress="", localPort=-1, remoteAddress="", remotePort=-1, mcastAddress='', mcastPort=-1, rcvSize=0, sndSize=0)
+                super(underlying, incoming, adapterName, connectionId, localAddress, localPort, remoteAddress, remotePort)
                 @mcastAddress = mcastAddress
                 @mcastPort = mcastPort
+                @rcvSize = rcvSize
+                @sndSize = sndSize
             end
+
+            attr_accessor :mcastAddress, :mcastPort, :rcvSize, :sndSize
         end
 
         if not defined?(::Ice::T_UDPConnectionInfo)
             T_UDPConnectionInfo = ::Ice::__declareLocalClass('::Ice::UDPConnectionInfo')
         end
 
-        T_UDPConnectionInfo.defineClass(UDPConnectionInfo, -1, false, false, nil, [], [
+        T_UDPConnectionInfo.defineClass(UDPConnectionInfo, -1, false, false, ::Ice::T_IPConnectionInfo, [
             ['mcastAddress', ::Ice::T_string, false, 0],
-            ['mcastPort', ::Ice::T_int, false, 0]
+            ['mcastPort', ::Ice::T_int, false, 0],
+            ['rcvSize', ::Ice::T_int, false, 0],
+            ['sndSize', ::Ice::T_int, false, 0]
         ])
-        UDPConnectionInfo_mixin::ICE_TYPE = T_UDPConnectionInfo
     end
 
     if not defined?(::Ice::T_HeaderDict)
         T_HeaderDict = ::Ice::__defineDictionary('::Ice::HeaderDict', ::Ice::T_string, ::Ice::T_string)
     end
 
-    if not defined?(::Ice::WSConnectionInfo_mixin)
-        module WSConnectionInfo_mixin
-
-            def inspect
-                ::Ice::__stringify(self, T_WSConnectionInfo)
-            end
+    if not defined?(::Ice::WSConnectionInfo_Mixin)
 
-            attr_accessor :headers
+        module ::Ice::WSConnectionInfo_Mixin
         end
-        class WSConnectionInfo
-            include WSConnectionInfo_mixin
-            
-            def WSConnectionInfo.ice_staticId()
-                '::Ice::WSConnectionInfo'
-            end
+        class WSConnectionInfo < ::Ice::ConnectionInfo
 
-            def initialize(incoming=false, adapterName='', connectionId='', rcvSize=0, sndSize=0, localAddress="", localPort=-1, remoteAddress="", remotePort=-1, headers=nil)
-                super(incoming, adapterName, connectionId, rcvSize, sndSize, localAddress, localPort, remoteAddress, remotePort)
+            def initialize(underlying=nil, incoming=false, adapterName='', connectionId='', headers=nil)
+                super(underlying, incoming, adapterName, connectionId)
                 @headers = headers
             end
+
+            attr_accessor :headers
         end
 
         if not defined?(::Ice::T_WSConnectionInfo)
             T_WSConnectionInfo = ::Ice::__declareLocalClass('::Ice::WSConnectionInfo')
         end
 
-        T_WSConnectionInfo.defineClass(WSConnectionInfo, -1, false, false, nil, [], [['headers', ::Ice::T_HeaderDict, false, 0]])
-        WSConnectionInfo_mixin::ICE_TYPE = T_WSConnectionInfo
+        T_WSConnectionInfo.defineClass(WSConnectionInfo, -1, false, false, ::Ice::T_ConnectionInfo, [['headers', ::Ice::T_HeaderDict, false, 0]])
     end
 end