corelink_send_stream.py

Go to the documentation of this file.

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


class SendStream:
    """
        Send Stream
    """
    def __init__(self,*arg):
        if len(arg)==2:
            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_SEND']) >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],SendStream):
                rhs = arg[0]
                self.update(rhs.stream_id,rhs.state,rhs.stream_ref)

    def send(self,*arg):
        """
            send
        """
        if len(arg)==1:
            msg = arg[0]
            federation_id = 0
            self.send_msg(self.state,self.stream_ref,self.stream_id,federation_id,msg,len(msg))
        if len(arg)==2:
            msg = arg[0]
            federation_id = arg[1]
            self.send_msg(self.state,self.stream_ref,self.stream_id,federation_id,msg,len(msg))
        if len(arg) == 3:
            msg = arg[0]
            msg_len = arg[1]
            federation_id = arg[2]
            self.send_msg(self.state,self.stream_ref,self.stream_id,federation_id,msg,msg_len)

    def send_json(self,msg,json_obj,server_check=False,federation_id=0):
        """
        send_json
        """
        corelink_const.LIB.sendMsgJson.argtypes = [ctypes.c_int,
                                                    ctypes.c_int,
                                                    ctypes.POINTER(ctypes.c_int),
                                                    ctypes.c_int,
                                                    ctypes.c_char_p,
                                                    ctypes.c_int,
                                                    ctypes.c_char_p,
                                                    ctypes.c_int,
                                                    ctypes.c_bool]
        state_c = ctypes.c_int(self.state)
        stream_ref_c = ctypes.c_int(self.stream_ref)
        stream_id_c = ctypes.c_int(self.stream_id)
        federation_id_c = ctypes.c_int(federation_id)
        msg_c = ctypes.create_string_buffer(msg.encode('utf-8'))
        msg_len_c = ctypes.c_int(len(msg))
        buffer = json.dumps(json_obj)
        buffer_c = ctypes.create_string_buffer(buffer.encode('utf-8'))
        buffer_len_c = ctypes.c_int(len(buffer))
        server_check_c = ctypes.c_bool(server_check)
        corelink_const.LIB.sendMsgJson(state_c,
                                        stream_ref_c,
                                        stream_id_c,
                                        federation_id_c,
                                        msg_c,
                                        msg_len_c,
                                        buffer_c,
                                        buffer_len_c,
                                        server_check_c)

    # pylint: disable=too-many-arguments
    # Seven is reasonable in this case.
    @staticmethod
    def send_msg(state,stream_ref,stream_id,federation_id,msg,msg_len):
        """"
        send message
        """
        corelink_const.LIB.sendMsg.argtypes = [ctypes.c_int,
                                                ctypes.c_int,
                                                ctypes.POINTER(ctypes.c_int),
                                                ctypes.c_int,
                                                ctypes.c_char_p,
                                                ctypes.c_int]
        state_c = ctypes.c_int(state)
        stream_ref_c = ctypes.c_int(stream_ref)
        stream_id_c = ctypes.c_int(stream_id)
        federation_id_c = ctypes.c_int(federation_id)
        msg_c = ctypes.create_string_buffer(msg.encode('utf-8'))
        msg_len_c = ctypes.c_int(msg_len)
        corelink_const.LIB.sendMsg(state_c,stream_ref_c,stream_id_c,federation_id_c,msg_c,msg_len_c)


    def update(self,stream_id,state,stream_ref):
        """"
            update the parameters
        """
        self.stream_id = stream_id
        self.state = state
        self.stream_ref = stream_ref