ruby-zeroc-ice 3.5.1-6.4ubuntu1 / usr / lib / ruby / vendor_ruby / Ice / Metrics.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 `Metrics.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

require 'Ice'
require 'Ice/BuiltinSequences.rb'

module IceMX

    if not defined?(::IceMX::T_StringIntDict)
        T_StringIntDict = ::Ice::__defineDictionary('::IceMX::StringIntDict', ::Ice::T_string, ::Ice::T_int)
    end

    if not defined?(::IceMX::Metrics_mixin)
        module Metrics_mixin
            include ::Ice::Object_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::Metrics']
            end

            def ice_id(current=nil)
                '::IceMX::Metrics'
            end

            def inspect
                ::Ice::__stringify(self, T_Metrics)
            end

            attr_accessor :id, :total, :current, :totalLifetime, :failures
        end
        class Metrics
            include Metrics_mixin
            
            def Metrics.ice_staticId()
                '::IceMX::Metrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0)
                @id = id
                @total = total
                @current = current
                @totalLifetime = totalLifetime
                @failures = failures
            end
        end
        module MetricsPrx_mixin
        end
        class MetricsPrx < ::Ice::ObjectPrx
            include MetricsPrx_mixin

            def MetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::Metrics', facetOrCtx, _ctx)
            end

            def MetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_Metrics)
            T_Metrics = ::Ice::__declareClass('::IceMX::Metrics')
            T_MetricsPrx = ::Ice::__declareProxy('::IceMX::Metrics')
        end

        T_Metrics.defineClass(Metrics, -1, false, false, nil, [], [
            ['id', ::Ice::T_string, false, 0],
            ['total', ::Ice::T_long, false, 0],
            ['current', ::Ice::T_int, false, 0],
            ['totalLifetime', ::Ice::T_long, false, 0],
            ['failures', ::Ice::T_int, false, 0]
        ])
        Metrics_mixin::ICE_TYPE = T_Metrics

        T_MetricsPrx.defineProxy(MetricsPrx, T_Metrics)
        MetricsPrx::ICE_TYPE = T_MetricsPrx
    end

    if not defined?(::IceMX::MetricsFailures)
        class MetricsFailures
            def initialize(id='', failures=nil)
                @id = id
                @failures = failures
            end

            def hash
                _h = 0
                _h = 5 * _h + @id.hash
                _h = 5 * _h + @failures.hash
                _h % 0x7fffffff
            end

            def ==(other)
                return false if
                    @id != other.id or
                    @failures != other.failures
                true
            end

            def eql?(other)
                return other.class == self.class && other == self
            end

            def inspect
                ::Ice::__stringify(self, T_MetricsFailures)
            end

            attr_accessor :id, :failures
        end

        T_MetricsFailures = ::Ice::__defineStruct('::IceMX::MetricsFailures', MetricsFailures, [
            ["id", ::Ice::T_string],
            ["failures", ::IceMX::T_StringIntDict]
        ])
    end

    if not defined?(::IceMX::T_MetricsFailuresSeq)
        T_MetricsFailuresSeq = ::Ice::__defineSequence('::IceMX::MetricsFailuresSeq', ::IceMX::T_MetricsFailures)
    end

    if not defined?(::IceMX::T_MetricsMap)
        T_MetricsMap = ::Ice::__defineSequence('::IceMX::MetricsMap', ::IceMX::T_Metrics)
    end

    if not defined?(::IceMX::T_MetricsView)
        T_MetricsView = ::Ice::__defineDictionary('::IceMX::MetricsView', ::Ice::T_string, ::IceMX::T_MetricsMap)
    end

    if not defined?(::IceMX::UnknownMetricsView)
        class UnknownMetricsView < Ice::UserException
            def initialize
            end

            def to_s
                'IceMX::UnknownMetricsView'
            end
        end

        T_UnknownMetricsView = ::Ice::__defineException('::IceMX::UnknownMetricsView', UnknownMetricsView, false, nil, [])
        UnknownMetricsView::ICE_TYPE = T_UnknownMetricsView
    end

    if not defined?(::IceMX::MetricsAdmin_mixin)
        module MetricsAdmin_mixin
            include ::Ice::Object_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::MetricsAdmin']
            end

            def ice_id(current=nil)
                '::IceMX::MetricsAdmin'
            end

            #
            # Operation signatures.
            #
            # def getMetricsViewNames(current=nil)
            # def enableMetricsView(name, current=nil)
            # def disableMetricsView(name, current=nil)
            # def getMetricsView(view, current=nil)
            # def getMapMetricsFailures(view, map, current=nil)
            # def getMetricsFailures(view, map, id, current=nil)

            def inspect
                ::Ice::__stringify(self, T_MetricsAdmin)
            end
        end
        class MetricsAdmin
            include MetricsAdmin_mixin
            
            def MetricsAdmin.ice_staticId()
                '::IceMX::MetricsAdmin'
            end
        end
        module MetricsAdminPrx_mixin

            def getMetricsViewNames(_ctx=nil)
                MetricsAdmin_mixin::OP_getMetricsViewNames.invoke(self, [], _ctx)
            end

            def enableMetricsView(name, _ctx=nil)
                MetricsAdmin_mixin::OP_enableMetricsView.invoke(self, [name], _ctx)
            end

            def disableMetricsView(name, _ctx=nil)
                MetricsAdmin_mixin::OP_disableMetricsView.invoke(self, [name], _ctx)
            end

            def getMetricsView(view, _ctx=nil)
                MetricsAdmin_mixin::OP_getMetricsView.invoke(self, [view], _ctx)
            end

            def getMapMetricsFailures(view, map, _ctx=nil)
                MetricsAdmin_mixin::OP_getMapMetricsFailures.invoke(self, [view, map], _ctx)
            end

            def getMetricsFailures(view, map, id, _ctx=nil)
                MetricsAdmin_mixin::OP_getMetricsFailures.invoke(self, [view, map, id], _ctx)
            end
        end
        class MetricsAdminPrx < ::Ice::ObjectPrx
            include MetricsAdminPrx_mixin

            def MetricsAdminPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::MetricsAdmin', facetOrCtx, _ctx)
            end

            def MetricsAdminPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_MetricsAdmin)
            T_MetricsAdmin = ::Ice::__declareClass('::IceMX::MetricsAdmin')
            T_MetricsAdminPrx = ::Ice::__declareProxy('::IceMX::MetricsAdmin')
        end

        T_MetricsAdmin.defineClass(MetricsAdmin, -1, true, false, nil, [], [])
        MetricsAdmin_mixin::ICE_TYPE = T_MetricsAdmin

        T_MetricsAdminPrx.defineProxy(MetricsAdminPrx, T_MetricsAdmin)
        MetricsAdminPrx::ICE_TYPE = T_MetricsAdminPrx

        MetricsAdmin_mixin::OP_getMetricsViewNames = ::Ice::__defineOperation('getMetricsViewNames', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [], [[::Ice::T_StringSeq, false, 0]], [::Ice::T_StringSeq, false, 0], [])
        MetricsAdmin_mixin::OP_enableMetricsView = ::Ice::__defineOperation('enableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
        MetricsAdmin_mixin::OP_disableMetricsView = ::Ice::__defineOperation('disableMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [], nil, [::IceMX::T_UnknownMetricsView])
        MetricsAdmin_mixin::OP_getMetricsView = ::Ice::__defineOperation('getMetricsView', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0]], [[::Ice::T_long, false, 0]], [::IceMX::T_MetricsView, false, 0], [::IceMX::T_UnknownMetricsView])
        MetricsAdmin_mixin::OP_getMapMetricsFailures = ::Ice::__defineOperation('getMapMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailuresSeq, false, 0], [::IceMX::T_UnknownMetricsView])
        MetricsAdmin_mixin::OP_getMetricsFailures = ::Ice::__defineOperation('getMetricsFailures', ::Ice::OperationMode::Normal, ::Ice::OperationMode::Normal, false, ::Ice::FormatType::SlicedFormat, [[::Ice::T_string, false, 0], [::Ice::T_string, false, 0], [::Ice::T_string, false, 0]], [], [::IceMX::T_MetricsFailures, false, 0], [::IceMX::T_UnknownMetricsView])
    end

    if not defined?(::IceMX::ThreadMetrics_mixin)
        module ThreadMetrics_mixin
            include ::IceMX::Metrics_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::Metrics', '::IceMX::ThreadMetrics']
            end

            def ice_id(current=nil)
                '::IceMX::ThreadMetrics'
            end

            def inspect
                ::Ice::__stringify(self, T_ThreadMetrics)
            end

            attr_accessor :inUseForIO, :inUseForUser, :inUseForOther
        end
        class ThreadMetrics < ::IceMX::Metrics
            include ThreadMetrics_mixin
            
            def ThreadMetrics.ice_staticId()
                '::IceMX::ThreadMetrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, inUseForIO=0, inUseForUser=0, inUseForOther=0)
                super(id, total, current, totalLifetime, failures)
                @inUseForIO = inUseForIO
                @inUseForUser = inUseForUser
                @inUseForOther = inUseForOther
            end
        end
        module ThreadMetricsPrx_mixin
            include ::IceMX::MetricsPrx_mixin
        end
        class ThreadMetricsPrx < ::Ice::ObjectPrx
            include ThreadMetricsPrx_mixin

            def ThreadMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::ThreadMetrics', facetOrCtx, _ctx)
            end

            def ThreadMetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_ThreadMetrics)
            T_ThreadMetrics = ::Ice::__declareClass('::IceMX::ThreadMetrics')
            T_ThreadMetricsPrx = ::Ice::__declareProxy('::IceMX::ThreadMetrics')
        end

        T_ThreadMetrics.defineClass(ThreadMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
            ['inUseForIO', ::Ice::T_int, false, 0],
            ['inUseForUser', ::Ice::T_int, false, 0],
            ['inUseForOther', ::Ice::T_int, false, 0]
        ])
        ThreadMetrics_mixin::ICE_TYPE = T_ThreadMetrics

        T_ThreadMetricsPrx.defineProxy(ThreadMetricsPrx, T_ThreadMetrics)
        ThreadMetricsPrx::ICE_TYPE = T_ThreadMetricsPrx
    end

    if not defined?(::IceMX::DispatchMetrics_mixin)
        module DispatchMetrics_mixin
            include ::IceMX::Metrics_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::DispatchMetrics', '::IceMX::Metrics']
            end

            def ice_id(current=nil)
                '::IceMX::DispatchMetrics'
            end

            def inspect
                ::Ice::__stringify(self, T_DispatchMetrics)
            end

            attr_accessor :userException, :size, :replySize
        end
        class DispatchMetrics < ::IceMX::Metrics
            include DispatchMetrics_mixin
            
            def DispatchMetrics.ice_staticId()
                '::IceMX::DispatchMetrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, userException=0, size=0, replySize=0)
                super(id, total, current, totalLifetime, failures)
                @userException = userException
                @size = size
                @replySize = replySize
            end
        end
        module DispatchMetricsPrx_mixin
            include ::IceMX::MetricsPrx_mixin
        end
        class DispatchMetricsPrx < ::Ice::ObjectPrx
            include DispatchMetricsPrx_mixin

            def DispatchMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::DispatchMetrics', facetOrCtx, _ctx)
            end

            def DispatchMetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_DispatchMetrics)
            T_DispatchMetrics = ::Ice::__declareClass('::IceMX::DispatchMetrics')
            T_DispatchMetricsPrx = ::Ice::__declareProxy('::IceMX::DispatchMetrics')
        end

        T_DispatchMetrics.defineClass(DispatchMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
            ['userException', ::Ice::T_int, false, 0],
            ['size', ::Ice::T_long, false, 0],
            ['replySize', ::Ice::T_long, false, 0]
        ])
        DispatchMetrics_mixin::ICE_TYPE = T_DispatchMetrics

        T_DispatchMetricsPrx.defineProxy(DispatchMetricsPrx, T_DispatchMetrics)
        DispatchMetricsPrx::ICE_TYPE = T_DispatchMetricsPrx
    end

    if not defined?(::IceMX::RemoteMetrics_mixin)
        module RemoteMetrics_mixin
            include ::IceMX::Metrics_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::Metrics', '::IceMX::RemoteMetrics']
            end

            def ice_id(current=nil)
                '::IceMX::RemoteMetrics'
            end

            def inspect
                ::Ice::__stringify(self, T_RemoteMetrics)
            end

            attr_accessor :size, :replySize
        end
        class RemoteMetrics < ::IceMX::Metrics
            include RemoteMetrics_mixin
            
            def RemoteMetrics.ice_staticId()
                '::IceMX::RemoteMetrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, size=0, replySize=0)
                super(id, total, current, totalLifetime, failures)
                @size = size
                @replySize = replySize
            end
        end
        module RemoteMetricsPrx_mixin
            include ::IceMX::MetricsPrx_mixin
        end
        class RemoteMetricsPrx < ::Ice::ObjectPrx
            include RemoteMetricsPrx_mixin

            def RemoteMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::RemoteMetrics', facetOrCtx, _ctx)
            end

            def RemoteMetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_RemoteMetrics)
            T_RemoteMetrics = ::Ice::__declareClass('::IceMX::RemoteMetrics')
            T_RemoteMetricsPrx = ::Ice::__declareProxy('::IceMX::RemoteMetrics')
        end

        T_RemoteMetrics.defineClass(RemoteMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
            ['size', ::Ice::T_long, false, 0],
            ['replySize', ::Ice::T_long, false, 0]
        ])
        RemoteMetrics_mixin::ICE_TYPE = T_RemoteMetrics

        T_RemoteMetricsPrx.defineProxy(RemoteMetricsPrx, T_RemoteMetrics)
        RemoteMetricsPrx::ICE_TYPE = T_RemoteMetricsPrx
    end

    if not defined?(::IceMX::InvocationMetrics_mixin)
        module InvocationMetrics_mixin
            include ::IceMX::Metrics_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::InvocationMetrics', '::IceMX::Metrics']
            end

            def ice_id(current=nil)
                '::IceMX::InvocationMetrics'
            end

            def inspect
                ::Ice::__stringify(self, T_InvocationMetrics)
            end

            attr_accessor :_retry, :userException, :remotes
        end
        class InvocationMetrics < ::IceMX::Metrics
            include InvocationMetrics_mixin
            
            def InvocationMetrics.ice_staticId()
                '::IceMX::InvocationMetrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, _retry=0, userException=0, remotes=nil)
                super(id, total, current, totalLifetime, failures)
                @_retry = _retry
                @userException = userException
                @remotes = remotes
            end
        end
        module InvocationMetricsPrx_mixin
            include ::IceMX::MetricsPrx_mixin
        end
        class InvocationMetricsPrx < ::Ice::ObjectPrx
            include InvocationMetricsPrx_mixin

            def InvocationMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::InvocationMetrics', facetOrCtx, _ctx)
            end

            def InvocationMetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_InvocationMetrics)
            T_InvocationMetrics = ::Ice::__declareClass('::IceMX::InvocationMetrics')
            T_InvocationMetricsPrx = ::Ice::__declareProxy('::IceMX::InvocationMetrics')
        end

        T_InvocationMetrics.defineClass(InvocationMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
            ['_retry', ::Ice::T_int, false, 0],
            ['userException', ::Ice::T_int, false, 0],
            ['remotes', ::IceMX::T_MetricsMap, false, 0]
        ])
        InvocationMetrics_mixin::ICE_TYPE = T_InvocationMetrics

        T_InvocationMetricsPrx.defineProxy(InvocationMetricsPrx, T_InvocationMetrics)
        InvocationMetricsPrx::ICE_TYPE = T_InvocationMetricsPrx
    end

    if not defined?(::IceMX::ConnectionMetrics_mixin)
        module ConnectionMetrics_mixin
            include ::IceMX::Metrics_mixin

            def ice_ids(current=nil)
                ['::Ice::Object', '::IceMX::ConnectionMetrics', '::IceMX::Metrics']
            end

            def ice_id(current=nil)
                '::IceMX::ConnectionMetrics'
            end

            def inspect
                ::Ice::__stringify(self, T_ConnectionMetrics)
            end

            attr_accessor :receivedBytes, :sentBytes
        end
        class ConnectionMetrics < ::IceMX::Metrics
            include ConnectionMetrics_mixin
            
            def ConnectionMetrics.ice_staticId()
                '::IceMX::ConnectionMetrics'
            end

            def initialize(id='', total=0, current=0, totalLifetime=0, failures=0, receivedBytes=0, sentBytes=0)
                super(id, total, current, totalLifetime, failures)
                @receivedBytes = receivedBytes
                @sentBytes = sentBytes
            end
        end
        module ConnectionMetricsPrx_mixin
            include ::IceMX::MetricsPrx_mixin
        end
        class ConnectionMetricsPrx < ::Ice::ObjectPrx
            include ConnectionMetricsPrx_mixin

            def ConnectionMetricsPrx.checkedCast(proxy, facetOrCtx=nil, _ctx=nil)
                ice_checkedCast(proxy, '::IceMX::ConnectionMetrics', facetOrCtx, _ctx)
            end

            def ConnectionMetricsPrx.uncheckedCast(proxy, facet=nil)
                ice_uncheckedCast(proxy, facet)
            end
        end

        if not defined?(::IceMX::T_ConnectionMetrics)
            T_ConnectionMetrics = ::Ice::__declareClass('::IceMX::ConnectionMetrics')
            T_ConnectionMetricsPrx = ::Ice::__declareProxy('::IceMX::ConnectionMetrics')
        end

        T_ConnectionMetrics.defineClass(ConnectionMetrics, -1, false, false, ::IceMX::T_Metrics, [], [
            ['receivedBytes', ::Ice::T_long, false, 0],
            ['sentBytes', ::Ice::T_long, false, 0]
        ])
        ConnectionMetrics_mixin::ICE_TYPE = T_ConnectionMetrics

        T_ConnectionMetricsPrx.defineProxy(ConnectionMetricsPrx, T_ConnectionMetrics)
        ConnectionMetricsPrx::ICE_TYPE = T_ConnectionMetricsPrx
    end
end