# -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2016 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.3
#
# <auto-generated>
#
# Generated from file `Endpoint.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy
import Ice_Version_ice
import Ice_BuiltinSequences_ice
import Ice_EndpointF_ice

# Included module Ice
_M_Ice = Ice.openModule('Ice')

# Start of module Ice
__name__ = 'Ice'

_M_Ice.TCPEndpointType = 1

_M_Ice.SSLEndpointType = 2

_M_Ice.UDPEndpointType = 3

_M_Ice.WSEndpointType = 4

_M_Ice.WSSEndpointType = 5

if 'EndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.EndpointInfo = Ice.createTempClass()
    class EndpointInfo(object):
        """
        Base class providing access to the endpoint details.
        Members:
        timeout -- The timeout for the endpoint in milliseconds. 0 means
        non-blocking, -1 means no timeout.
        compress -- Specifies whether or not compression should be used if
        available when using this endpoint.
        """
        def __init__(self, timeout=0, compress=False):
            if Ice.getType(self) == _M_Ice.EndpointInfo:
                raise RuntimeError('Ice.EndpointInfo is an abstract class')
            self.timeout = timeout
            self.compress = compress

        def type(self):
            """
            Returns the type of the endpoint.
            """
            pass

        def datagram(self):
            """
            Returns true if this endpoint is a datagram endpoint.
            """
            pass

        def secure(self):
            """
            Returns true if this endpoint is a secure endpoint.
            """
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_EndpointInfo)

        __repr__ = __str__

    _M_Ice._t_EndpointInfo = IcePy.defineClass('::Ice::EndpointInfo', EndpointInfo, -1, (), True, False, None, (), (
        ('timeout', (), IcePy._t_int, False, 0),
        ('compress', (), IcePy._t_bool, False, 0)
    ))
    EndpointInfo._ice_type = _M_Ice._t_EndpointInfo

    _M_Ice.EndpointInfo = EndpointInfo
    del EndpointInfo

if 'Endpoint' not in _M_Ice.__dict__:
    _M_Ice.Endpoint = Ice.createTempClass()
    class Endpoint(object):
        """
        The user-level interface to an endpoint.
        """
        def __init__(self):
            if Ice.getType(self) == _M_Ice.Endpoint:
                raise RuntimeError('Ice.Endpoint is an abstract class')

        def toString(self):
            """
            Return a string representation of the endpoint.
            Returns: The string representation of the endpoint.
            """
            pass

        def getInfo(self):
            """
            Returns the endpoint information.
            Returns: The endpoint information class.
            """
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_Endpoint)

        __repr__ = __str__

    _M_Ice._t_Endpoint = IcePy.defineClass('::Ice::Endpoint', Endpoint, -1, (), True, False, None, (), ())
    Endpoint._ice_type = _M_Ice._t_Endpoint

    _M_Ice.Endpoint = Endpoint
    del Endpoint

if 'IPEndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.IPEndpointInfo = Ice.createTempClass()
    class IPEndpointInfo(_M_Ice.EndpointInfo):
        """
        Provides access to the address details of a IP endpoint.
        Members:
        host -- The host or address configured with the endpoint.
        port -- The port number.
        sourceAddress -- The source IP address.
        """
        def __init__(self, timeout=0, compress=False, host='', port=0, sourceAddress=''):
            if Ice.getType(self) == _M_Ice.IPEndpointInfo:
                raise RuntimeError('Ice.IPEndpointInfo is an abstract class')
            _M_Ice.EndpointInfo.__init__(self, timeout, compress)
            self.host = host
            self.port = port
            self.sourceAddress = sourceAddress

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_IPEndpointInfo)

        __repr__ = __str__

    _M_Ice._t_IPEndpointInfo = IcePy.defineClass('::Ice::IPEndpointInfo', IPEndpointInfo, -1, (), True, False, _M_Ice._t_EndpointInfo, (), (
        ('host', (), IcePy._t_string, False, 0),
        ('port', (), IcePy._t_int, False, 0),
        ('sourceAddress', (), IcePy._t_string, False, 0)
    ))
    IPEndpointInfo._ice_type = _M_Ice._t_IPEndpointInfo

    _M_Ice.IPEndpointInfo = IPEndpointInfo
    del IPEndpointInfo

if 'TCPEndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.TCPEndpointInfo = Ice.createTempClass()
    class TCPEndpointInfo(_M_Ice.IPEndpointInfo):
        """
        Provides access to a TCP endpoint information.
        """
        def __init__(self, timeout=0, compress=False, host='', port=0, sourceAddress=''):
            if Ice.getType(self) == _M_Ice.TCPEndpointInfo:
                raise RuntimeError('Ice.TCPEndpointInfo is an abstract class')
            _M_Ice.IPEndpointInfo.__init__(self, timeout, compress, host, port, sourceAddress)

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_TCPEndpointInfo)

        __repr__ = __str__

    _M_Ice._t_TCPEndpointInfo = IcePy.defineClass('::Ice::TCPEndpointInfo', TCPEndpointInfo, -1, (), True, False, _M_Ice._t_IPEndpointInfo, (), ())
    TCPEndpointInfo._ice_type = _M_Ice._t_TCPEndpointInfo

    _M_Ice.TCPEndpointInfo = TCPEndpointInfo
    del TCPEndpointInfo

if 'UDPEndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.UDPEndpointInfo = Ice.createTempClass()
    class UDPEndpointInfo(_M_Ice.IPEndpointInfo):
        """
        Provides access to an UDP endpoint information.
        Members:
        mcastInterface -- The multicast interface.
        mcastTtl -- The multicast time-to-live (or hops).
        """
        def __init__(self, timeout=0, compress=False, host='', port=0, sourceAddress='', mcastInterface='', mcastTtl=0):
            if Ice.getType(self) == _M_Ice.UDPEndpointInfo:
                raise RuntimeError('Ice.UDPEndpointInfo is an abstract class')
            _M_Ice.IPEndpointInfo.__init__(self, timeout, compress, host, port, sourceAddress)
            self.mcastInterface = mcastInterface
            self.mcastTtl = mcastTtl

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_UDPEndpointInfo)

        __repr__ = __str__

    _M_Ice._t_UDPEndpointInfo = IcePy.defineClass('::Ice::UDPEndpointInfo', UDPEndpointInfo, -1, (), True, False, _M_Ice._t_IPEndpointInfo, (), (
        ('mcastInterface', (), IcePy._t_string, False, 0),
        ('mcastTtl', (), IcePy._t_int, False, 0)
    ))
    UDPEndpointInfo._ice_type = _M_Ice._t_UDPEndpointInfo

    _M_Ice.UDPEndpointInfo = UDPEndpointInfo
    del UDPEndpointInfo

if 'WSEndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.WSEndpointInfo = Ice.createTempClass()
    class WSEndpointInfo(_M_Ice.TCPEndpointInfo):
        """
        Provides access to a WebSocket endpoint information.
        Members:
        resource -- The URI configured with the endpoint.
        """
        def __init__(self, timeout=0, compress=False, host='', port=0, sourceAddress='', resource=''):
            if Ice.getType(self) == _M_Ice.WSEndpointInfo:
                raise RuntimeError('Ice.WSEndpointInfo is an abstract class')
            _M_Ice.TCPEndpointInfo.__init__(self, timeout, compress, host, port, sourceAddress)
            self.resource = resource

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_WSEndpointInfo)

        __repr__ = __str__

    _M_Ice._t_WSEndpointInfo = IcePy.defineClass('::Ice::WSEndpointInfo', WSEndpointInfo, -1, (), True, False, _M_Ice._t_TCPEndpointInfo, (), (('resource', (), IcePy._t_string, False, 0),))
    WSEndpointInfo._ice_type = _M_Ice._t_WSEndpointInfo

    _M_Ice.WSEndpointInfo = WSEndpointInfo
    del WSEndpointInfo

if 'OpaqueEndpointInfo' not in _M_Ice.__dict__:
    _M_Ice.OpaqueEndpointInfo = Ice.createTempClass()
    class OpaqueEndpointInfo(_M_Ice.EndpointInfo):
        """
        Provides access to the details of an opaque endpoint.
        Members:
        rawEncoding -- The encoding version of the opaque endpoint (to decode or
        encode the rawBytes).
        rawBytes -- The raw encoding of the opaque endpoint.
        """
        def __init__(self, timeout=0, compress=False, rawEncoding=Ice._struct_marker, rawBytes=None):
            if Ice.getType(self) == _M_Ice.OpaqueEndpointInfo:
                raise RuntimeError('Ice.OpaqueEndpointInfo is an abstract class')
            _M_Ice.EndpointInfo.__init__(self, timeout, compress)
            if rawEncoding is Ice._struct_marker:
                self.rawEncoding = _M_Ice.EncodingVersion()
            else:
                self.rawEncoding = rawEncoding
            self.rawBytes = rawBytes

        def __str__(self):
            return IcePy.stringify(self, _M_Ice._t_OpaqueEndpointInfo)

        __repr__ = __str__

    _M_Ice._t_OpaqueEndpointInfo = IcePy.defineClass('::Ice::OpaqueEndpointInfo', OpaqueEndpointInfo, -1, (), True, False, _M_Ice._t_EndpointInfo, (), (
        ('rawEncoding', (), _M_Ice._t_EncodingVersion, False, 0),
        ('rawBytes', (), _M_Ice._t_ByteSeq, False, 0)
    ))
    OpaqueEndpointInfo._ice_type = _M_Ice._t_OpaqueEndpointInfo

    _M_Ice.OpaqueEndpointInfo = OpaqueEndpointInfo
    del OpaqueEndpointInfo

# End of module Ice
