zeroc-ice 3.6b1

data/lib/IceGrid/Locator.rb

@@ -0,0 +1,105 @@
+# **********************************************************************
+#
+# 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 `Locator.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+require 'Ice'
+require 'Ice/Locator.rb'
+
+module IceGrid
+
+    if not defined?(::IceGrid::T_Registry)
+        T_Registry = ::Ice::__declareClass('::IceGrid::Registry')
+        T_RegistryPrx = ::Ice::__declareProxy('::IceGrid::Registry')
+    end
+
+    if not defined?(::IceGrid::T_Query)
+        T_Query = ::Ice::__declareClass('::IceGrid::Query')
+        T_QueryPrx = ::Ice::__declareProxy('::IceGrid::Query')
+    end
+
+    if not defined?(::IceGrid::Locator_mixin)
+        module Locator_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Locator', '::Ice::Object', '::IceGrid::Locator']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::Locator'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def getLocalRegistry(current=nil)
+            # def getLocalQuery(current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_Locator)
+            end
+        end
+        class Locator
+            include Locator_mixin
+            
+            def Locator.ice_staticId()
+                '::IceGrid::Locator'
+            end
+        end
+        module LocatorPrx_mixin
+            include ::Ice::LocatorPrx_mixin
+
+            def getLocalRegistry(_ctx=nil)
+                Locator_mixin::OP_getLocalRegistry.invoke(self, [], _ctx)
+            end
+
+            def getLocalQuery(_ctx=nil)
+                Locator_mixin::OP_getLocalQuery.invoke(self, [], _ctx)
+            end
+        end
+        class LocatorPrx < ::Ice::ObjectPrx
+            include LocatorPrx_mixin
+
+            def LocatorPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::Locator', facetOrCtx, _ctx)
+            end
+
+            def LocatorPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def LocatorPrx.ice_staticId()
+                '::IceGrid::Locator'
+            end
+        end
+
+        if not defined?(::IceGrid::T_Locator)
+            T_Locator = ::Ice::__declareClass('::IceGrid::Locator')
+            T_LocatorPrx = ::Ice::__declareProxy('::IceGrid::Locator')
+        end
+
+        T_Locator.defineClass(Locator, -1, true, false, nil, [::Ice::T_Locator], [])
+        Locator_mixin::ICE_TYPE = T_Locator
+
+        T_LocatorPrx.defineProxy(LocatorPrx, T_Locator)
+        LocatorPrx::ICE_TYPE = T_LocatorPrx
+
+        Locator_mixin::OP_getLocalRegistry = ::Ice::__defineOperation('getLocalRegistry', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::IceGrid::T_RegistryPrx, false, 0], [])
+        Locator_mixin::OP_getLocalQuery = ::Ice::__defineOperation('getLocalQuery', ::Ice::OperationMode::Idempotent, ::Ice::OperationMode::Idempotent, false, nil, [], [], [::IceGrid::T_QueryPrx, false, 0], [])
+    end
+end

data/lib/IceGrid/Observer.rb

@@ -0,0 +1,571 @@
+# **********************************************************************
+#
+# 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 `Observer.ice'
+#
+# Warning: do not edit this file.
+#
+# </auto-generated>
+#
+
+require 'Ice'
+require 'Glacier2/Session.rb'
+require 'IceGrid/Exception.rb'
+require 'IceGrid/Descriptor.rb'
+require 'IceGrid/Admin.rb'
+
+module IceGrid
+
+    if not defined?(::IceGrid::ServerDynamicInfo)
+        class ServerDynamicInfo
+            def initialize(id='', state=::IceGrid::ServerState::Inactive, pid=0, enabled=false)
+                @id = id
+                @state = state
+                @pid = pid
+                @enabled = enabled
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @state.hash
+                _h = 5 * _h + @pid.hash
+                _h = 5 * _h + @enabled.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if
+                    @id != other.id or
+                    @state != other.state or
+                    @pid != other.pid or
+                    @enabled != other.enabled
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            def inspect
+                ::Ice::__stringify(self, T_ServerDynamicInfo)
+            end
+
+            attr_accessor :id, :state, :pid, :enabled
+        end
+
+        T_ServerDynamicInfo = ::Ice::__defineStruct('::IceGrid::ServerDynamicInfo', ServerDynamicInfo, [
+            ["id", ::Ice::T_string],
+            ["state", ::IceGrid::T_ServerState],
+            ["pid", ::Ice::T_int],
+            ["enabled", ::Ice::T_bool]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_ServerDynamicInfoSeq)
+        T_ServerDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::ServerDynamicInfoSeq', ::IceGrid::T_ServerDynamicInfo)
+    end
+
+    if not defined?(::IceGrid::AdapterDynamicInfo)
+        class AdapterDynamicInfo
+            def initialize(id='', proxy=nil)
+                @id = id
+                @proxy = proxy
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @id.hash
+                _h = 5 * _h + @proxy.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if
+                    @id != other.id or
+                    @proxy != other.proxy
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            def inspect
+                ::Ice::__stringify(self, T_AdapterDynamicInfo)
+            end
+
+            attr_accessor :id, :proxy
+        end
+
+        T_AdapterDynamicInfo = ::Ice::__defineStruct('::IceGrid::AdapterDynamicInfo', AdapterDynamicInfo, [
+            ["id", ::Ice::T_string],
+            ["proxy", ::Ice::T_ObjectPrx]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_AdapterDynamicInfoSeq)
+        T_AdapterDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::AdapterDynamicInfoSeq', ::IceGrid::T_AdapterDynamicInfo)
+    end
+
+    if not defined?(::IceGrid::NodeDynamicInfo)
+        class NodeDynamicInfo
+            def initialize(info=::IceGrid::NodeInfo.new, servers=nil, adapters=nil)
+                @info = info
+                @servers = servers
+                @adapters = adapters
+            end
+
+            def hash
+                _h = 0
+                _h = 5 * _h + @info.hash
+                _h = 5 * _h + @servers.hash
+                _h = 5 * _h + @adapters.hash
+                _h % 0x7fffffff
+            end
+
+            def ==(other)
+                return false if
+                    @info != other.info or
+                    @servers != other.servers or
+                    @adapters != other.adapters
+                true
+            end
+
+            def eql?(other)
+                return other.class == self.class && other == self
+            end
+
+            def inspect
+                ::Ice::__stringify(self, T_NodeDynamicInfo)
+            end
+
+            attr_accessor :info, :servers, :adapters
+        end
+
+        T_NodeDynamicInfo = ::Ice::__defineStruct('::IceGrid::NodeDynamicInfo', NodeDynamicInfo, [
+            ["info", ::IceGrid::T_NodeInfo],
+            ["servers", ::IceGrid::T_ServerDynamicInfoSeq],
+            ["adapters", ::IceGrid::T_AdapterDynamicInfoSeq]
+        ])
+    end
+
+    if not defined?(::IceGrid::T_NodeDynamicInfoSeq)
+        T_NodeDynamicInfoSeq = ::Ice::__defineSequence('::IceGrid::NodeDynamicInfoSeq', ::IceGrid::T_NodeDynamicInfo)
+    end
+
+    if not defined?(::IceGrid::NodeObserver_mixin)
+        module NodeObserver_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Object', '::IceGrid::NodeObserver']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::NodeObserver'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def nodeInit(nodes, current=nil)
+            # def nodeUp(node, current=nil)
+            # def nodeDown(name, current=nil)
+            # def updateServer(node, updatedInfo, current=nil)
+            # def updateAdapter(node, updatedInfo, current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_NodeObserver)
+            end
+        end
+        class NodeObserver
+            include NodeObserver_mixin
+            
+            def NodeObserver.ice_staticId()
+                '::IceGrid::NodeObserver'
+            end
+        end
+        module NodeObserverPrx_mixin
+
+            def nodeInit(nodes, _ctx=nil)
+                NodeObserver_mixin::OP_nodeInit.invoke(self, [nodes], _ctx)
+            end
+
+            def nodeUp(node, _ctx=nil)
+                NodeObserver_mixin::OP_nodeUp.invoke(self, [node], _ctx)
+            end
+
+            def nodeDown(name, _ctx=nil)
+                NodeObserver_mixin::OP_nodeDown.invoke(self, [name], _ctx)
+            end
+
+            def updateServer(node, updatedInfo, _ctx=nil)
+                NodeObserver_mixin::OP_updateServer.invoke(self, [node, updatedInfo], _ctx)
+            end
+
+            def updateAdapter(node, updatedInfo, _ctx=nil)
+                NodeObserver_mixin::OP_updateAdapter.invoke(self, [node, updatedInfo], _ctx)
+            end
+        end
+        class NodeObserverPrx < ::Ice::ObjectPrx
+            include NodeObserverPrx_mixin
+
+            def NodeObserverPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::NodeObserver', facetOrCtx, _ctx)
+            end
+
+            def NodeObserverPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def NodeObserverPrx.ice_staticId()
+                '::IceGrid::NodeObserver'
+            end
+        end
+
+        if not defined?(::IceGrid::T_NodeObserver)
+            T_NodeObserver = ::Ice::__declareClass('::IceGrid::NodeObserver')
+            T_NodeObserverPrx = ::Ice::__declareProxy('::IceGrid::NodeObserver')
+        end
+
+        T_NodeObserver.defineClass(NodeObserver, -1, true, false, nil, [], [])
+        NodeObserver_mixin::ICE_TYPE = T_NodeObserver
+
+        T_NodeObserverPrx.defineProxy(NodeObserverPrx, T_NodeObserver)
+        NodeObserverPrx::ICE_TYPE = T_NodeObserverPrx
+
+        NodeObserver_mixin::OP_nodeInit = ::Ice::__defineOperation('nodeInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_NodeDynamicInfoSeq, false, 0]], [], nil, [])
+        NodeObserver_mixin::OP_nodeUp = ::Ice::__defineOperation('nodeUp', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_NodeDynamicInfo, false, 0]], [], nil, [])
+        NodeObserver_mixin::OP_nodeDown = ::Ice::__defineOperation('nodeDown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
+        NodeObserver_mixin::OP_updateServer = ::Ice::__defineOperation('updateServer', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::IceGrid::T_ServerDynamicInfo, false, 0]], [], nil, [])
+        NodeObserver_mixin::OP_updateAdapter = ::Ice::__defineOperation('updateAdapter', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0], [::IceGrid::T_AdapterDynamicInfo, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::ApplicationObserver_mixin)
+        module ApplicationObserver_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Object', '::IceGrid::ApplicationObserver']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::ApplicationObserver'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def applicationInit(serial, applications, current=nil)
+            # def applicationAdded(serial, desc, current=nil)
+            # def applicationRemoved(serial, name, current=nil)
+            # def applicationUpdated(serial, desc, current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_ApplicationObserver)
+            end
+        end
+        class ApplicationObserver
+            include ApplicationObserver_mixin
+            
+            def ApplicationObserver.ice_staticId()
+                '::IceGrid::ApplicationObserver'
+            end
+        end
+        module ApplicationObserverPrx_mixin
+
+            def applicationInit(serial, applications, _ctx=nil)
+                ApplicationObserver_mixin::OP_applicationInit.invoke(self, [serial, applications], _ctx)
+            end
+
+            def applicationAdded(serial, desc, _ctx=nil)
+                ApplicationObserver_mixin::OP_applicationAdded.invoke(self, [serial, desc], _ctx)
+            end
+
+            def applicationRemoved(serial, name, _ctx=nil)
+                ApplicationObserver_mixin::OP_applicationRemoved.invoke(self, [serial, name], _ctx)
+            end
+
+            def applicationUpdated(serial, desc, _ctx=nil)
+                ApplicationObserver_mixin::OP_applicationUpdated.invoke(self, [serial, desc], _ctx)
+            end
+        end
+        class ApplicationObserverPrx < ::Ice::ObjectPrx
+            include ApplicationObserverPrx_mixin
+
+            def ApplicationObserverPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::ApplicationObserver', facetOrCtx, _ctx)
+            end
+
+            def ApplicationObserverPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def ApplicationObserverPrx.ice_staticId()
+                '::IceGrid::ApplicationObserver'
+            end
+        end
+
+        if not defined?(::IceGrid::T_ApplicationObserver)
+            T_ApplicationObserver = ::Ice::__declareClass('::IceGrid::ApplicationObserver')
+            T_ApplicationObserverPrx = ::Ice::__declareProxy('::IceGrid::ApplicationObserver')
+        end
+
+        T_ApplicationObserver.defineClass(ApplicationObserver, -1, true, false, nil, [], [])
+        ApplicationObserver_mixin::ICE_TYPE = T_ApplicationObserver
+
+        T_ApplicationObserverPrx.defineProxy(ApplicationObserverPrx, T_ApplicationObserver)
+        ApplicationObserverPrx::ICE_TYPE = T_ApplicationObserverPrx
+
+        ApplicationObserver_mixin::OP_applicationInit = ::Ice::__defineOperation('applicationInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationInfoSeq, false, 0]], [], nil, [])
+        ApplicationObserver_mixin::OP_applicationAdded = ::Ice::__defineOperation('applicationAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationInfo, false, 0]], [], nil, [])
+        ApplicationObserver_mixin::OP_applicationRemoved = ::Ice::__defineOperation('applicationRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::Ice::T_string, false, 0]], [], nil, [])
+        ApplicationObserver_mixin::OP_applicationUpdated = ::Ice::__defineOperation('applicationUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_int, false, 0], [::IceGrid::T_ApplicationUpdateInfo, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::AdapterObserver_mixin)
+        module AdapterObserver_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Object', '::IceGrid::AdapterObserver']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::AdapterObserver'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def adapterInit(adpts, current=nil)
+            # def adapterAdded(info, current=nil)
+            # def adapterUpdated(info, current=nil)
+            # def adapterRemoved(id, current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_AdapterObserver)
+            end
+        end
+        class AdapterObserver
+            include AdapterObserver_mixin
+            
+            def AdapterObserver.ice_staticId()
+                '::IceGrid::AdapterObserver'
+            end
+        end
+        module AdapterObserverPrx_mixin
+
+            def adapterInit(adpts, _ctx=nil)
+                AdapterObserver_mixin::OP_adapterInit.invoke(self, [adpts], _ctx)
+            end
+
+            def adapterAdded(info, _ctx=nil)
+                AdapterObserver_mixin::OP_adapterAdded.invoke(self, [info], _ctx)
+            end
+
+            def adapterUpdated(info, _ctx=nil)
+                AdapterObserver_mixin::OP_adapterUpdated.invoke(self, [info], _ctx)
+            end
+
+            def adapterRemoved(id, _ctx=nil)
+                AdapterObserver_mixin::OP_adapterRemoved.invoke(self, [id], _ctx)
+            end
+        end
+        class AdapterObserverPrx < ::Ice::ObjectPrx
+            include AdapterObserverPrx_mixin
+
+            def AdapterObserverPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::AdapterObserver', facetOrCtx, _ctx)
+            end
+
+            def AdapterObserverPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def AdapterObserverPrx.ice_staticId()
+                '::IceGrid::AdapterObserver'
+            end
+        end
+
+        if not defined?(::IceGrid::T_AdapterObserver)
+            T_AdapterObserver = ::Ice::__declareClass('::IceGrid::AdapterObserver')
+            T_AdapterObserverPrx = ::Ice::__declareProxy('::IceGrid::AdapterObserver')
+        end
+
+        T_AdapterObserver.defineClass(AdapterObserver, -1, true, false, nil, [], [])
+        AdapterObserver_mixin::ICE_TYPE = T_AdapterObserver
+
+        T_AdapterObserverPrx.defineProxy(AdapterObserverPrx, T_AdapterObserver)
+        AdapterObserverPrx::ICE_TYPE = T_AdapterObserverPrx
+
+        AdapterObserver_mixin::OP_adapterInit = ::Ice::__defineOperation('adapterInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfoSeq, false, 0]], [], nil, [])
+        AdapterObserver_mixin::OP_adapterAdded = ::Ice::__defineOperation('adapterAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfo, false, 0]], [], nil, [])
+        AdapterObserver_mixin::OP_adapterUpdated = ::Ice::__defineOperation('adapterUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_AdapterInfo, false, 0]], [], nil, [])
+        AdapterObserver_mixin::OP_adapterRemoved = ::Ice::__defineOperation('adapterRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::ObjectObserver_mixin)
+        module ObjectObserver_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Object', '::IceGrid::ObjectObserver']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::ObjectObserver'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def objectInit(objects, current=nil)
+            # def objectAdded(info, current=nil)
+            # def objectUpdated(info, current=nil)
+            # def objectRemoved(id, current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_ObjectObserver)
+            end
+        end
+        class ObjectObserver
+            include ObjectObserver_mixin
+            
+            def ObjectObserver.ice_staticId()
+                '::IceGrid::ObjectObserver'
+            end
+        end
+        module ObjectObserverPrx_mixin
+
+            def objectInit(objects, _ctx=nil)
+                ObjectObserver_mixin::OP_objectInit.invoke(self, [objects], _ctx)
+            end
+
+            def objectAdded(info, _ctx=nil)
+                ObjectObserver_mixin::OP_objectAdded.invoke(self, [info], _ctx)
+            end
+
+            def objectUpdated(info, _ctx=nil)
+                ObjectObserver_mixin::OP_objectUpdated.invoke(self, [info], _ctx)
+            end
+
+            def objectRemoved(id, _ctx=nil)
+                ObjectObserver_mixin::OP_objectRemoved.invoke(self, [id], _ctx)
+            end
+        end
+        class ObjectObserverPrx < ::Ice::ObjectPrx
+            include ObjectObserverPrx_mixin
+
+            def ObjectObserverPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::ObjectObserver', facetOrCtx, _ctx)
+            end
+
+            def ObjectObserverPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def ObjectObserverPrx.ice_staticId()
+                '::IceGrid::ObjectObserver'
+            end
+        end
+
+        if not defined?(::IceGrid::T_ObjectObserver)
+            T_ObjectObserver = ::Ice::__declareClass('::IceGrid::ObjectObserver')
+            T_ObjectObserverPrx = ::Ice::__declareProxy('::IceGrid::ObjectObserver')
+        end
+
+        T_ObjectObserver.defineClass(ObjectObserver, -1, true, false, nil, [], [])
+        ObjectObserver_mixin::ICE_TYPE = T_ObjectObserver
+
+        T_ObjectObserverPrx.defineProxy(ObjectObserverPrx, T_ObjectObserver)
+        ObjectObserverPrx::ICE_TYPE = T_ObjectObserverPrx
+
+        ObjectObserver_mixin::OP_objectInit = ::Ice::__defineOperation('objectInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfoSeq, false, 0]], [], nil, [])
+        ObjectObserver_mixin::OP_objectAdded = ::Ice::__defineOperation('objectAdded', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfo, false, 0]], [], nil, [])
+        ObjectObserver_mixin::OP_objectUpdated = ::Ice::__defineOperation('objectUpdated', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_ObjectInfo, false, 0]], [], nil, [])
+        ObjectObserver_mixin::OP_objectRemoved = ::Ice::__defineOperation('objectRemoved', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_Identity, false, 0]], [], nil, [])
+    end
+
+    if not defined?(::IceGrid::RegistryObserver_mixin)
+        module RegistryObserver_mixin
+            include ::Ice::Object_mixin
+
+            def ice_ids(current=nil)
+                ['::Ice::Object', '::IceGrid::RegistryObserver']
+            end
+
+            def ice_id(current=nil)
+                '::IceGrid::RegistryObserver'
+            end
+
+            #
+            # Operation signatures.
+            #
+            # def registryInit(registries, current=nil)
+            # def registryUp(node, current=nil)
+            # def registryDown(name, current=nil)
+
+            def inspect
+                ::Ice::__stringify(self, T_RegistryObserver)
+            end
+        end
+        class RegistryObserver
+            include RegistryObserver_mixin
+            
+            def RegistryObserver.ice_staticId()
+                '::IceGrid::RegistryObserver'
+            end
+        end
+        module RegistryObserverPrx_mixin
+
+            def registryInit(registries, _ctx=nil)
+                RegistryObserver_mixin::OP_registryInit.invoke(self, [registries], _ctx)
+            end
+
+            def registryUp(node, _ctx=nil)
+                RegistryObserver_mixin::OP_registryUp.invoke(self, [node], _ctx)
+            end
+
+            def registryDown(name, _ctx=nil)
+                RegistryObserver_mixin::OP_registryDown.invoke(self, [name], _ctx)
+            end
+        end
+        class RegistryObserverPrx < ::Ice::ObjectPrx
+            include RegistryObserverPrx_mixin
+
+            def RegistryObserverPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
+                ice_checkedCast(proxy, '::IceGrid::RegistryObserver', facetOrCtx, _ctx)
+            end
+
+            def RegistryObserverPrx.uncheckedCast(proxy, facet=nil)
+                ice_uncheckedCast(proxy, facet)
+            end
+            def RegistryObserverPrx.ice_staticId()
+                '::IceGrid::RegistryObserver'
+            end
+        end
+
+        if not defined?(::IceGrid::T_RegistryObserver)
+            T_RegistryObserver = ::Ice::__declareClass('::IceGrid::RegistryObserver')
+            T_RegistryObserverPrx = ::Ice::__declareProxy('::IceGrid::RegistryObserver')
+        end
+
+        T_RegistryObserver.defineClass(RegistryObserver, -1, true, false, nil, [], [])
+        RegistryObserver_mixin::ICE_TYPE = T_RegistryObserver
+
+        T_RegistryObserverPrx.defineProxy(RegistryObserverPrx, T_RegistryObserver)
+        RegistryObserverPrx::ICE_TYPE = T_RegistryObserverPrx
+
+        RegistryObserver_mixin::OP_registryInit = ::Ice::__defineOperation('registryInit', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_RegistryInfoSeq, false, 0]], [], nil, [])
+        RegistryObserver_mixin::OP_registryUp = ::Ice::__defineOperation('registryUp', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::IceGrid::T_RegistryInfo, false, 0]], [], nil, [])
+        RegistryObserver_mixin::OP_registryDown = ::Ice::__defineOperation('registryDown', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, nil, [[::Ice::T_string, false, 0]], [], nil, [])
+    end
+end