def pl_send_new_parameter_list(self, parameters): """ Used to inform the PaPI framework about all DParameters provided by this plugins. :param parameters: List of DParameters :return: """ if not isinstance(parameters, list): raise pe.WrongType("parameters", list) if len(parameters) == 0: raise pe.WrongLength("parameters", len(parameters), ">0") parameter_list_to_send = [ ] # The callback handler cannot be send over process boundaries, so we need to remove it before sending for i in range(len(parameters)): parameter = parameters[i] if not isinstance(parameter, DParameter): raise pe.WrongType('parameters[' + str(i) + ']', DParameter) self.__plugin_parameter_list[parameter.name] = parameter tmp_parameter = copy.copy(parameter) tmp_parameter.callback_function_handler = None parameter_list_to_send.append(tmp_parameter) opt = DOptionalData() opt.parameter_list = parameter_list_to_send event = Event.data.NewParameter(self.__id__, 0, opt) self._Core_event_queue__.put(event)
def pl_send_delete_parameter(self, parameter): """ Used to inform the PaPI framework that a single DParameter was deleted. :param parameter: DParameter which should be deleted. :return: """ parameter_name = None if isinstance(parameter, DParameter) == False and isinstance( parameter, str) == False: raise pe.WrongType("parameter", [DParameter, str]) if isinstance(parameter, DParameter): parameter_name = parameter.name if isinstance(parameter, str): parameter_name = parameter if parameter_name in self.__plugin_parameter_list: self.__plugin_parameter_list.pop(parameter_name) event = Event.data.DeleteParameter(self.__id__, 0, parameter_name) self._Core_event_queue__.put(event)
def pl_send_new_event_list(self, events): """ Used to inform the PaPI framework about all DEvents provided by this plugins. :param events: List of DEvents :return: """ if not isinstance(events, list): raise pe.WrongType("events", list) if len(events) == 0: raise pe.WrongLength("events", len(events), ">0") for i in range(len(events)): event = events[i] if not isinstance(event, DEvent): raise pe.WrongType('events[' + str(i) + ']', DEvent) self.pl_send_new_block_list(events)
def pl_send_new_data(self, block_name, time_line, data): """ This function is called by plugins to send new data for a single block. :param block_name: Name of the block :param time_line: A time vector :param data: Data containing the values in a hash array of signal names as key. :return: """ if not isinstance(time_line, list): raise pe.WrongType("time", list) if not isinstance(data, dict): raise pe.WrongType("data", dict) dataHash = data dataHash[CORE_TIME_SIGNAL] = time_line opt = DOptionalData(DATA=dataHash) opt.data_source_id = self.__id__ opt.block_name = block_name event = Event.data.NewData(self.__id__, 0, opt, None) self._Core_event_queue__.put(event)
def pl_emit_event(self, data, event): """ This function is used by plugins to emit a specific event. :param data: New value provided by the DEvent :param event: DEvent which should be emitted. :return: """ if isinstance(event, DEvent) == False and isinstance(event, str) == False: raise pe.WrongType("block", [DEvent, str]) self._send_parameter_change(data, event)
def pl_send_new_block_list(self, blocks): """ Used to inform the PaPI framework about all DBlocks provided by this plugins. :param blocks: List of DBlocks :return: """ if not isinstance(blocks, list): raise pe.WrongType("blocks", list) if len(blocks) == 0: raise pe.WrongLength("blocks", len(blocks), ">0") for i in range(len(blocks)): block = blocks[i] if not isinstance(block, DBlock): raise pe.WrongType('blocks[' + str(i) + ']', DBlock) opt = DOptionalData() opt.block_list = blocks event = Event.data.NewBlock(self.__id__, 0, opt) self._Core_event_queue__.put(event)
def pl_send_new_parameter_list(self, parameters): """ Used to inform the PaPI framework about all DParameters provided by this plugins. :param parameters: List of DParameters :return: """ if not isinstance(parameters, list): raise pe.WrongType("parameters", list) if len(parameters) == 0: raise pe.WrongLength("parameters", len(parameters), ">0") for i in range(len(parameters)): parameter = parameters[i] if not isinstance(parameter, DParameter): raise pe.WrongType('parameters[' + str(i) + ']', DParameter) opt = DOptionalData() opt.parameter_list = parameters event = Event.data.NewParameter(self.__id__, 0, opt) self._Core_event_queue__.put(event)
def pl_send_delete_block(self, block): """ Used to inform the PaPI framework that a single DBlock was deleted. :param block: Block which should be deleted. :return: """ block_name = None if isinstance(block, DBlock) == False and isinstance(block, str) == False: raise pe.WrongType("parameters", [DBlock, str]) if isinstance(block, DBlock): block_name = block.name if isinstance(block, str): block_name = block event = Event.data.DeleteBlock(self.__id__, 0, block_name) self._Core_event_queue__.put(event)
def _send_parameter_change(self, data, block): """ Internal function, should be not directly used anymore. :param data: :param block: :return: """ opt = DOptionalData(DATA=data) opt.data_source_id = self.__id__ opt.is_parameter = True if isinstance(block, DBlock) is False and isinstance(block, str) is False: raise pe.WrongType("block", [DBlock, str]) if isinstance(block, DBlock): opt.block_name = block.name if isinstance(block, str): opt.block_name = block event = Event.data.NewData(self.__id__, 0, opt, None) self._Core_event_queue__.put(event)