ruby-zeroc-ice 3.5.1-6.4ubuntu1 / usr / lib / ruby / vendor_ruby / Ice / Instrumentation.rb

# **********************************************************************
#
# Copyright (c) 2003-2013 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.5.1
#
# <auto-generated>
#
# Generated from file `Instrumentation.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

require 'Ice'
require 'Ice/EndpointF.rb'
require 'Ice/ConnectionF.rb'
require 'Ice/Current.rb'

module Ice

    module Instrumentation

        if not defined?(::Ice::Instrumentation::Observer_mixin)
            module Observer_mixin

                #
                # Operation signatures.
                #
                # def attach()
                # def detach()
                # def failed(exceptionName)

                def inspect
                    ::Ice::__stringify(self, T_Observer)
                end
            end
            class Observer
                include Observer_mixin
                
                def Observer.ice_staticId()
                    '::Ice::Instrumentation::Observer'
                end
            end

            if not defined?(::Ice::Instrumentation::T_Observer)
                T_Observer = ::Ice::__declareLocalClass('::Ice::Instrumentation::Observer')
            end

            T_Observer.defineClass(Observer, -1, true, false, nil, [], [])
            Observer_mixin::ICE_TYPE = T_Observer
        end

        if not defined?(::Ice::Instrumentation::ThreadState)
            class ThreadState
                include Comparable

                def initialize(name, value)
                    @name = name
                    @value = value
                end

                def ThreadState.from_int(val)
                    @@_enumerators[val]
                end

                def to_s
                    @name
                end

                def to_i
                    @value
                end

                def <=>(other)
                    other.is_a?(ThreadState) or raise ArgumentError, "value must be a ThreadState"
                    @value <=> other.to_i
                end

                def hash
                    @value.hash
                end

                def inspect
                    @name + "(#{@value})"
                end

                def ThreadState.each(&block)
                    @@_enumerators.each_value(&block)
                end

                ThreadStateIdle = ThreadState.new("ThreadStateIdle", 0)
                ThreadStateInUseForIO = ThreadState.new("ThreadStateInUseForIO", 1)
                ThreadStateInUseForUser = ThreadState.new("ThreadStateInUseForUser", 2)
                ThreadStateInUseForOther = ThreadState.new("ThreadStateInUseForOther", 3)

                @@_enumerators = {0=>ThreadStateIdle, 1=>ThreadStateInUseForIO, 2=>ThreadStateInUseForUser, 3=>ThreadStateInUseForOther}

                def ThreadState._enumerators
                    @@_enumerators
                end

                private_class_method :new
            end

            T_ThreadState = ::Ice::__defineEnum('::Ice::Instrumentation::ThreadState', ThreadState, ThreadState::_enumerators)
        end

        if not defined?(::Ice::Instrumentation::ThreadObserver_mixin)
            module ThreadObserver_mixin

                #
                # Operation signatures.
                #
                # def stateChanged(oldState, newState)

                def inspect
                    ::Ice::__stringify(self, T_ThreadObserver)
                end
            end
            class ThreadObserver
                include ThreadObserver_mixin
                
                def ThreadObserver.ice_staticId()
                    '::Ice::Instrumentation::ThreadObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_ThreadObserver)
                T_ThreadObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::ThreadObserver')
            end

            T_ThreadObserver.defineClass(ThreadObserver, -1, true, false, nil, [::Ice::Instrumentation::T_Observer], [])
            ThreadObserver_mixin::ICE_TYPE = T_ThreadObserver
        end

        if not defined?(::Ice::Instrumentation::ConnectionState)
            class ConnectionState
                include Comparable

                def initialize(name, value)
                    @name = name
                    @value = value
                end

                def ConnectionState.from_int(val)
                    @@_enumerators[val]
                end

                def to_s
                    @name
                end

                def to_i
                    @value
                end

                def <=>(other)
                    other.is_a?(ConnectionState) or raise ArgumentError, "value must be a ConnectionState"
                    @value <=> other.to_i
                end

                def hash
                    @value.hash
                end

                def inspect
                    @name + "(#{@value})"
                end

                def ConnectionState.each(&block)
                    @@_enumerators.each_value(&block)
                end

                ConnectionStateValidating = ConnectionState.new("ConnectionStateValidating", 0)
                ConnectionStateHolding = ConnectionState.new("ConnectionStateHolding", 1)
                ConnectionStateActive = ConnectionState.new("ConnectionStateActive", 2)
                ConnectionStateClosing = ConnectionState.new("ConnectionStateClosing", 3)
                ConnectionStateClosed = ConnectionState.new("ConnectionStateClosed", 4)

                @@_enumerators = {0=>ConnectionStateValidating, 1=>ConnectionStateHolding, 2=>ConnectionStateActive, 3=>ConnectionStateClosing, 4=>ConnectionStateClosed}

                def ConnectionState._enumerators
                    @@_enumerators
                end

                private_class_method :new
            end

            T_ConnectionState = ::Ice::__defineEnum('::Ice::Instrumentation::ConnectionState', ConnectionState, ConnectionState::_enumerators)
        end

        if not defined?(::Ice::Instrumentation::ConnectionObserver_mixin)
            module ConnectionObserver_mixin

                #
                # Operation signatures.
                #
                # def sentBytes(num)
                # def receivedBytes(num)

                def inspect
                    ::Ice::__stringify(self, T_ConnectionObserver)
                end
            end
            class ConnectionObserver
                include ConnectionObserver_mixin
                
                def ConnectionObserver.ice_staticId()
                    '::Ice::Instrumentation::ConnectionObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_ConnectionObserver)
                T_ConnectionObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::ConnectionObserver')
            end

            T_ConnectionObserver.defineClass(ConnectionObserver, -1, true, false, nil, [::Ice::Instrumentation::T_Observer], [])
            ConnectionObserver_mixin::ICE_TYPE = T_ConnectionObserver
        end

        if not defined?(::Ice::Instrumentation::DispatchObserver_mixin)
            module DispatchObserver_mixin

                #
                # Operation signatures.
                #
                # def userException()
                # def reply(size)

                def inspect
                    ::Ice::__stringify(self, T_DispatchObserver)
                end
            end
            class DispatchObserver
                include DispatchObserver_mixin
                
                def DispatchObserver.ice_staticId()
                    '::Ice::Instrumentation::DispatchObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_DispatchObserver)
                T_DispatchObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::DispatchObserver')
            end

            T_DispatchObserver.defineClass(DispatchObserver, -1, true, false, nil, [::Ice::Instrumentation::T_Observer], [])
            DispatchObserver_mixin::ICE_TYPE = T_DispatchObserver
        end

        if not defined?(::Ice::Instrumentation::RemoteObserver_mixin)
            module RemoteObserver_mixin

                #
                # Operation signatures.
                #
                # def reply(size)

                def inspect
                    ::Ice::__stringify(self, T_RemoteObserver)
                end
            end
            class RemoteObserver
                include RemoteObserver_mixin
                
                def RemoteObserver.ice_staticId()
                    '::Ice::Instrumentation::RemoteObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_RemoteObserver)
                T_RemoteObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::RemoteObserver')
            end

            T_RemoteObserver.defineClass(RemoteObserver, -1, true, false, nil, [::Ice::Instrumentation::T_Observer], [])
            RemoteObserver_mixin::ICE_TYPE = T_RemoteObserver
        end

        if not defined?(::Ice::Instrumentation::InvocationObserver_mixin)
            module InvocationObserver_mixin

                #
                # Operation signatures.
                #
                # def retried()
                # def userException()
                # def getRemoteObserver(con, endpt, requestId, size)

                def inspect
                    ::Ice::__stringify(self, T_InvocationObserver)
                end
            end
            class InvocationObserver
                include InvocationObserver_mixin
                
                def InvocationObserver.ice_staticId()
                    '::Ice::Instrumentation::InvocationObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_InvocationObserver)
                T_InvocationObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::InvocationObserver')
            end

            T_InvocationObserver.defineClass(InvocationObserver, -1, true, false, nil, [::Ice::Instrumentation::T_Observer], [])
            InvocationObserver_mixin::ICE_TYPE = T_InvocationObserver
        end

        if not defined?(::Ice::Instrumentation::ObserverUpdater_mixin)
            module ObserverUpdater_mixin

                #
                # Operation signatures.
                #
                # def updateConnectionObservers()
                # def updateThreadObservers()

                def inspect
                    ::Ice::__stringify(self, T_ObserverUpdater)
                end
            end
            class ObserverUpdater
                include ObserverUpdater_mixin
                
                def ObserverUpdater.ice_staticId()
                    '::Ice::Instrumentation::ObserverUpdater'
                end
            end

            if not defined?(::Ice::Instrumentation::T_ObserverUpdater)
                T_ObserverUpdater = ::Ice::__declareLocalClass('::Ice::Instrumentation::ObserverUpdater')
            end

            T_ObserverUpdater.defineClass(ObserverUpdater, -1, true, false, nil, [], [])
            ObserverUpdater_mixin::ICE_TYPE = T_ObserverUpdater
        end

        if not defined?(::Ice::Instrumentation::CommunicatorObserver_mixin)
            module CommunicatorObserver_mixin

                #
                # Operation signatures.
                #
                # def getConnectionEstablishmentObserver(endpt, connector)
                # def getEndpointLookupObserver(endpt)
                # def getConnectionObserver(c, e, s, o)
                # def getThreadObserver(parent, id, s, o)
                # def getInvocationObserver(prx, operation, ctx)
                # def getDispatchObserver(c, size)
                # def setObserverUpdater(updater)

                def inspect
                    ::Ice::__stringify(self, T_CommunicatorObserver)
                end
            end
            class CommunicatorObserver
                include CommunicatorObserver_mixin
                
                def CommunicatorObserver.ice_staticId()
                    '::Ice::Instrumentation::CommunicatorObserver'
                end
            end

            if not defined?(::Ice::Instrumentation::T_CommunicatorObserver)
                T_CommunicatorObserver = ::Ice::__declareLocalClass('::Ice::Instrumentation::CommunicatorObserver')
            end

            T_CommunicatorObserver.defineClass(CommunicatorObserver, -1, true, false, nil, [], [])
            CommunicatorObserver_mixin::ICE_TYPE = T_CommunicatorObserver
        end
    end
end