source: geniuswebcore/geniusweb/connection/ConnectionEnd.py@ 99

from abc import ABC
from typing import TypeVar, Generic, List, Optional

from tudelft.utilities.listener.Listenable import Listenable
from uri.uri import URI

from geniusweb.references.Reference import Reference


INTYPE = TypeVar('INTYPE')
OUTTYPE = TypeVar('OUTTYPE')

class ConnectionEnd(Listenable[INTYPE], Generic[INTYPE,OUTTYPE]):
        '''
        One end of a general two-way connection. incoming data is reported through
        the {@link Listenable} channel, sending events of the INTYPE.
        <p>
        
        The connection mechanism assumed here is fundamentally asymmetric. One side
        is "Connectable", the other side is a ConnectionEnd created (usually from a
        {@link Reference}. This matches the typical client-server system (web
        architecture).
        
        <p>
        If an internal error occurs, eg a socket failure, timeout, or parser error, a
        null event is sent into the Listenable. {@link #getError()} can be called to
        find out about the error.
        @param <INTYPE>  the type of incoming messages (incoming for the user of this
                         connection end). Incoming messages are received through
                         Listener#not. Incoming messages are usually asynchronous.
        @param <OUTTYPE> the type of outgoing messages (outgoing for the user of this
                         connection end). Outgoing messages can be sent directly with
                         #send.
        '''

        def send(self,data:OUTTYPE ):
                '''
                Send data out (and flush the output so that there are no excessive delays
                in sending the data). This call is assumed to return immediately (never
                block, eg on synchronized, Thread.sleep, IO, etc). When this is called
                multiple times in sequence, the data should arrive at the receiver end in
                the same order.
                
                @param data the data to be sent.
                @throws ConnectionError if the data failed to be sent.
                '''
        
        def getReference(self) -> Reference:
                '''
                @return Reference that was used to create this connection
                '''

        def getRemoteURI(self)->URI: 
                '''
                @return the URI of the remote endpoint that makes up the connection. This
                         is a URI that uniquely identifies the remote object.
                '''

        def close(self):
                '''
                Close the connection. Should return immediately (not block). Before
                really closing, this should attempt to send out possibly cached messages
                before closing the connection.
                '''
        def getError(self) -> Optional[Exception]:
                '''
                @return the latest internal error, or null if no error occured. If the
                        channel is closed, this is set to {@link SocketException} "Socket
                        closed", even if the close was a "normal" termination eg when
                        {@link #close()} was called.
                '''