def _try_create_new_match(self, first_partial_match: PartialMatch,
                              second_partial_match: PartialMatch,
                              first_event_defs: List[Tuple[int, QItem]],
                              second_event_defs: List[Tuple[int, QItem]]):

        if self._sliding_window != timedelta.max and \
                abs(first_partial_match.last_timestamp - second_partial_match.first_timestamp) > self._sliding_window:
            return

        events_for_new_match = merge_according_to(first_event_defs,
                                                  second_event_defs,
                                                  first_partial_match.events,
                                                  second_partial_match.events,
                                                  key=get_index)

        if self.top_operator == SeqOperator:
            if not is_sorted(events_for_new_match, key=lambda x: x.timestamp):
                return False
        elif self.top_operator == AndOperator:
            """
                To be implemented later when class AndNode will be implemented
            """
            raise NotImplementedError()
        elif self.top_operator == OrOperator:
            """
                To be implemented later when class OrNode will be implemented
            """
            raise NotImplementedError()

        return self._validate_new_match(events_for_new_match)
Exemplo n.º 2
0
 def _merge_events_for_new_match(
         self, first_event_defs: List[PrimitiveEventDefinition],
         second_event_defs: List[PrimitiveEventDefinition],
         first_event_list: List[Event], second_event_list: List[Event]):
     return merge_according_to(first_event_defs,
                               second_event_defs,
                               first_event_list,
                               second_event_list,
                               key=lambda x: x.index)
Exemplo n.º 3
0
 def _merge_events_for_new_match(self, first_event_defs: List[Tuple[int,
                                                                    QItem]],
                                 second_event_defs: List[Tuple[int, QItem]],
                                 first_event_list: List[Event],
                                 second_event_list: List[Event]):
     return merge_according_to(first_event_defs,
                               second_event_defs,
                               first_event_list,
                               second_event_list,
                               key=lambda x: x[0])