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

require 'Ice'
require 'Ice/Version.rb'
require 'Ice/BuiltinSequences.rb'
require 'Ice/EndpointF.rb'

module Ice

    TCPEndpointType = 1

    UDPEndpointType = 3

    if not defined?(::Ice::EndpointInfo_mixin)
        module EndpointInfo_mixin

            #
            # Operation signatures.
            #
            # def type()
            # def datagram()
            # def secure()

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

            attr_accessor :timeout, :compress
        end
        class EndpointInfo
            include EndpointInfo_mixin
            
            def EndpointInfo.ice_staticId()
                '::Ice::EndpointInfo'
            end

            def initialize(timeout=0, compress=false)
                @timeout = timeout
                @compress = compress
            end
        end

        if not defined?(::Ice::T_EndpointInfo)
            T_EndpointInfo = ::Ice::__declareLocalClass('::Ice::EndpointInfo')
        end

        T_EndpointInfo.defineClass(EndpointInfo, -1, true, false, nil, [], [
            ['timeout', ::Ice::T_int, false, 0],
            ['compress', ::Ice::T_bool, false, 0]
        ])
        EndpointInfo_mixin::ICE_TYPE = T_EndpointInfo
    end

    if not defined?(::Ice::Endpoint_mixin)
        module Endpoint_mixin

            #
            # Operation signatures.
            #
            # def toString()
            # def getInfo()

            def inspect
                ::Ice::__stringify(self, T_Endpoint)
            end
        end
        class Endpoint
            include Endpoint_mixin
            
            def Endpoint.ice_staticId()
                '::Ice::Endpoint'
            end
        end

        if not defined?(::Ice::T_Endpoint)
            T_Endpoint = ::Ice::__declareLocalClass('::Ice::Endpoint')
        end

        T_Endpoint.defineClass(Endpoint, -1, true, false, nil, [], [])
        Endpoint_mixin::ICE_TYPE = T_Endpoint
    end

    if not defined?(::Ice::IPEndpointInfo_mixin)
        module IPEndpointInfo_mixin

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

            attr_accessor :host, :port
        end
        class IPEndpointInfo
            include IPEndpointInfo_mixin
            
            def IPEndpointInfo.ice_staticId()
                '::Ice::IPEndpointInfo'
            end

            def initialize(timeout=0, compress=false, host='', port=0)
                super(timeout, compress)
                @host = host
                @port = port
            end
        end

        if not defined?(::Ice::T_IPEndpointInfo)
            T_IPEndpointInfo = ::Ice::__declareLocalClass('::Ice::IPEndpointInfo')
        end

        T_IPEndpointInfo.defineClass(IPEndpointInfo, -1, true, false, nil, [], [
            ['host', ::Ice::T_string, false, 0],
            ['port', ::Ice::T_int, false, 0]
        ])
        IPEndpointInfo_mixin::ICE_TYPE = T_IPEndpointInfo
    end

    if not defined?(::Ice::TCPEndpointInfo_mixin)
        module TCPEndpointInfo_mixin

            def inspect
                ::Ice::__stringify(self, T_TCPEndpointInfo)
            end
        end
        class TCPEndpointInfo
            include TCPEndpointInfo_mixin
            
            def TCPEndpointInfo.ice_staticId()
                '::Ice::TCPEndpointInfo'
            end

            def initialize(timeout=0, compress=false, host='', port=0)
                super(timeout, compress, host, port)
            end
        end

        if not defined?(::Ice::T_TCPEndpointInfo)
            T_TCPEndpointInfo = ::Ice::__declareLocalClass('::Ice::TCPEndpointInfo')
        end

        T_TCPEndpointInfo.defineClass(TCPEndpointInfo, -1, true, false, nil, [], [])
        TCPEndpointInfo_mixin::ICE_TYPE = T_TCPEndpointInfo
    end

    if not defined?(::Ice::UDPEndpointInfo_mixin)
        module UDPEndpointInfo_mixin

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

            attr_accessor :mcastInterface, :mcastTtl
        end
        class UDPEndpointInfo
            include UDPEndpointInfo_mixin
            
            def UDPEndpointInfo.ice_staticId()
                '::Ice::UDPEndpointInfo'
            end

            def initialize(timeout=0, compress=false, host='', port=0, mcastInterface='', mcastTtl=0)
                super(timeout, compress, host, port)
                @mcastInterface = mcastInterface
                @mcastTtl = mcastTtl
            end
        end

        if not defined?(::Ice::T_UDPEndpointInfo)
            T_UDPEndpointInfo = ::Ice::__declareLocalClass('::Ice::UDPEndpointInfo')
        end

        T_UDPEndpointInfo.defineClass(UDPEndpointInfo, -1, true, false, nil, [], [
            ['mcastInterface', ::Ice::T_string, false, 0],
            ['mcastTtl', ::Ice::T_int, false, 0]
        ])
        UDPEndpointInfo_mixin::ICE_TYPE = T_UDPEndpointInfo
    end

    if not defined?(::Ice::OpaqueEndpointInfo_mixin)
        module OpaqueEndpointInfo_mixin

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

            attr_accessor :rawEncoding, :rawBytes
        end
        class OpaqueEndpointInfo
            include OpaqueEndpointInfo_mixin
            
            def OpaqueEndpointInfo.ice_staticId()
                '::Ice::OpaqueEndpointInfo'
            end

            def initialize(timeout=0, compress=false, rawEncoding=::Ice::EncodingVersion.new, rawBytes=nil)
                super(timeout, compress)
                @rawEncoding = rawEncoding
                @rawBytes = rawBytes
            end
        end

        if not defined?(::Ice::T_OpaqueEndpointInfo)
            T_OpaqueEndpointInfo = ::Ice::__declareLocalClass('::Ice::OpaqueEndpointInfo')
        end

        T_OpaqueEndpointInfo.defineClass(OpaqueEndpointInfo, -1, true, false, nil, [], [
            ['rawEncoding', ::Ice::T_EncodingVersion, false, 0],
            ['rawBytes', ::Ice::T_ByteSeq, false, 0]
        ])
        OpaqueEndpointInfo_mixin::ICE_TYPE = T_OpaqueEndpointInfo
    end
end