corelink_recv_stream.py

Go to the documentation of this file.

""""
    @file corelink_recv_stream.py
    Handler class for the receiver streams.
    A container for the stream id and necessary data to call associated functions.
"""
import ctypes
import corelink_const
import corelink_stream_data

# pylint: disable=global-statement
# global declaration is essential

RECV_CALLBACK_TYPE = ctypes.CFUNCTYPE(None,(ctypes.c_int),
                                        (ctypes.c_int),ctypes.
                                        POINTER(ctypes.c_char),
                                        (ctypes.c_int),
                                        (ctypes.c_int),
                                        ctypes.c_void_p)
CALLBACK_TYPE = ctypes.CFUNCTYPE(None,(ctypes.c_int),(ctypes.c_int),ctypes.c_wchar_p)

RECV_CALLBACK_JSON_TYPE = ctypes.CFUNCTYPE(None,(ctypes.c_int),
                                            (ctypes.c_int),
                                            ctypes.POINTER(ctypes.c_char),
                                            (ctypes.c_int),
                                            (ctypes.c_int),
                                            ctypes.c_void_p)
CALLBACK_JSON_TYPE = ctypes.CFUNCTYPE(None,(ctypes.c_int),
                                        (ctypes.c_int),
                                        ctypes.c_wchar_p,
                                        ctypes.c_wchar_p)
# pylint: disable=too-many-arguments
# Six is reasonable in this case.
def recv_callback_json(recv_id,send_id,msg,json_len,msg_len,callback):
    """
        Recv callback for Json
    """
    if callback is None:
        return
    global CALLBACK_JSON_TYPE
    callback = ctypes.cast(callback, CALLBACK_JSON_TYPE)
    json_data = msg[:json_len].decode("utf-8")
    msg_data= msg[json_len:json_len+msg_len].decode("utf-8")
    callback(recv_id, send_id, msg_data,json_data)

def recv_callback(recv_id,send_id,msg,json_len,msg_len,callback):
    """
        recv call back
    """
    if callback is None:
        return
    global CALLBACK_TYPE
    msg_data= msg[json_len:json_len+msg_len].decode("utf-8")
    callback = ctypes.cast(callback, CALLBACK_TYPE)
    callback(recv_id, send_id, msg_data)

class RecvStream:
    """
        recv stream
    """
    def __init__(self,*arg):
        if len(arg)==3:
            self.update(arg[0],arg[1],arg[2])
        if len(arg)==1:
            if isinstance(arg[0],corelink_stream_data.StreamData):
                stream_data = arg[0]
                if(stream_data.state & corelink_const.STATE_CODES['STREAM_STATE_RECV']) >0:
                    self.update(stream_data.stream_id,stream_data.state,stream_data.stream_ref)
                else:
                    self.update(-1,corelink_const.STATE_CODES['STREAM_STATE_NONE'],-1)
            if isinstance(arg[0],RecvStream):
                rhs = arg[0]
                self.update(rhs.stream_id,rhs.state,rhs.stream_ref)
        self.receive_callback = None
        self.callback = None

    def update(self,stream_id,state,stream_ref):
        """
            update parameters
        """
        self.stream_id = stream_id
        self.state = state
        self.stream_ref = stream_ref
        self.func_c = None
        self.temp_f = None

    def set_on_receive(self):
        """
            set on receive
        """
        corelink_const.LIB.setOnRecv.restype = ctypes.c_void_p
        _ = corelink_const.LIB.setOnRecv((ctypes.c_int(self.state)),
                                        (ctypes.c_int(self.stream_ref)),
                                        ctypes.byref(ctypes.c_int(self.stream_id)),None,None)

    def set_on_receive_msg(self,func):
        """
            set on receive message
        """
        global RECV_CALLBACK_TYPE,CALLBACK_TYPE
        self.receive_callback = RECV_CALLBACK_TYPE(recv_callback)
        callback = CALLBACK_TYPE(func)
        self.callback = ctypes.cast(callback,ctypes.c_void_p)
        corelink_const.LIB.setOnRecv.restype = ctypes.c_void_p
        _ = corelink_const.LIB.setOnRecv((ctypes.c_int(self.state)),
                                        (ctypes.c_int(self.stream_ref)),
                                        ctypes.byref(ctypes.c_int(self.stream_id)),
                                        self.receive_callback,self.callback)

    def set_on_receive_msg_json(self,func):
        """
            set on receive msg json
        """
        global RECV_CALLBACK_JSON_TYPE,CALLBACK_JSON_TYPE
        self.receive_callback = RECV_CALLBACK_JSON_TYPE(recv_callback_json)
        callback = CALLBACK_JSON_TYPE(func)
        self.callback = ctypes.cast(callback,ctypes.c_void_p)
        corelink_const.LIB.setOnRecv.restype = ctypes.c_void_p
        _ = corelink_const.LIB.setOnRecv((ctypes.c_int(self.state)),
                                            (ctypes.c_int(self.stream_ref)),
                                            ctypes.byref(ctypes.c_int(self.stream_id)),
                                            self.receive_callback,self.callback)

    @staticmethod
    def get_receiver_handler(stream_id):
        """
            get receiver handler
        """
        corelink_const.LIB.getStreamState.argtypes = [ctypes.POINTER(ctypes.c_int)]
        corelink_const.LIB.getStreamState.restype = ctypes.c_int
        state = corelink_const.LIB.getStreamState(ctypes.byref(ctypes.c_int(stream_id)))

        corelink_const.LIB.getStreamRef.argtypes = [ctypes.POINTER(ctypes.c_int)]
        corelink_const.LIB.getStreamRef.restype = ctypes.c_int
        ref = corelink_const.LIB.getStreamRef(ctypes.byref(ctypes.c_int(stream_id)))
        if(ref <0 or (state & corelink_const.STATE_CODES['STREAM_STATE_RECV'])==0 ):
            return RecvStream()
        return RecvStream(stream_id,state,ref)