def get(self, TA, TB): assert isinstance(TA, MegaState_Target) assert isinstance(TB, MegaState_Target) if TA.drop_out_f: if TB.drop_out_f: return TA TA_scheme = self.__drop_out_scheme_a elif TA.target_state_index is not None: if TB.target_state_index is not None and TA.target_state_index == TB.target_state_index: return TA TA_scheme = (TA.target_state_index,) * self.__length_a else: TA_scheme = TA.scheme if TB.drop_out_f: # TA was not drop-out, otherwise we would have returned earlier TB_scheme = self.__drop_out_scheme_b elif TB.target_state_index is not None: # TA was not the same door, otherwise we would have returned earlier TB_scheme = (TB.target_state_index,) * self.__length_b else: TB_scheme = TB.scheme return MegaState_Target.create(TA_scheme + TB_scheme)
def prepare_transition_map(TM): """Character Path objects contain transition maps of the form list of (interval, DoorID) which has now to be transformed into the form list of (interval, MegaState_Target) This is the form that code generation requires for MegaState-s. """ def adapt(Target): if isinstance(Target, DoorID): return Target.state_index return Target return [ (interval, MegaState_Target.create(adapt(target))) \ for interval, target in TM ]
def get(self, TA, TB): """RETURNS: A MegaState_Target which represents the combination of target A and target B. If both are equal the MegaState_Target may have the '.target_state_index' set. If not a 'scheme' is developped is developed, which determines a target based on a state key, i.e. 'target_state_index = scheme[state_key]'. """ assert isinstance(TA, MegaState_Target) assert isinstance(TB, MegaState_Target) if TA.drop_out_f: if TB.drop_out_f: return TA TA_scheme = self.__drop_out_scheme_a elif TA.target_state_index is not None: if TB.target_state_index is not None and TA.target_state_index == TB.target_state_index: return TA TA_scheme = (TA.target_state_index,) * self.__length_a else: TA_scheme = TA.scheme if TB.drop_out_f: # TA was not drop-out, otherwise we would have returned earlier TB_scheme = self.__drop_out_scheme_b elif TB.target_state_index is not None: # TA was not the same door, otherwise we would have returned earlier TB_scheme = (TB.target_state_index,) * self.__length_b else: TB_scheme = TB.scheme return MegaState_Target.create(TA_scheme + TB_scheme)
def get(self, TA, TB): """RETURNS: A MegaState_Target which represents the combination of target A and target B. If both are equal the MegaState_Target may have the '.target_state_index' set. If not a 'scheme' is developped is developed, which determines a target based on a state key, i.e. 'target_state_index = scheme[state_key]'. """ assert isinstance(TA, MegaState_Target) assert isinstance(TB, MegaState_Target) if TA.drop_out_f: if TB.drop_out_f: return TA TA_scheme = self.__drop_out_scheme_a elif TA.target_state_index is not None: if TB.target_state_index is not None and TA.target_state_index == TB.target_state_index: return TA TA_scheme = (TA.target_state_index, ) * self.__length_a else: TA_scheme = TA.scheme if TB.drop_out_f: # TA was not drop-out, otherwise we would have returned earlier TB_scheme = self.__drop_out_scheme_b elif TB.target_state_index is not None: # TA was not the same door, otherwise we would have returned earlier TB_scheme = (TB.target_state_index, ) * self.__length_b else: TB_scheme = TB.scheme return MegaState_Target.create(TA_scheme + TB_scheme)
def combine_maps(StateA, StateB): """RETURNS: -- Transition map = combined transition map of StateA and StateB. -- List of target schemes that have been identified. NOTE: If the entries of both states are uniform, then a transition to itself of both states can be implemented as a recursion of the template state without knowing the particular states. EXPLANATION: This function combines two transition maps. A transition map is a list of tuples: [ ... (interval, target) ... ] Each tuple tells about a character range [interval.begin, interval.end) where the state triggers to the given target. In a normal AnalyzerState the target is the index of the target state. In a TemplateState, though, multiple states are combined. A TemplateState operates on behalf of a state which is identified by its 'state_key'. If two states (even TemplateStates) are combined the trigger maps are observed, e.g. Trigger Map A Trigger Map B [ [ ([0, 10), DropOut) ([0, 10), State_4) ([10, 15), State_0) ([10, 15), State_1) ([15, 20), DropOut) ([15, 20), State_0) ([20, 21), State_1) ([20, 21), DropOut) ([21, 255), DropOut) ([21, 255), State_0) ] ] For some intervals, the target is the same. But for some it is different. In a TemplateState, the intervals are associated with MegaState_Target objects. A MegaState_Target object tells the target state dependent on the 'state_key'. The above example may result in a transition map as below: Trigger Map A [ # intervals: target schemes: ( [0, 10), { A: DropOut, B: State_4, }, ( [10, 15), { A: State_0, B: State_1, }, ( [15, 20), { A: DropOut, B: State_0, }, ( [20, 21), { A: State_1, B: DropOut, }, ( [21, 255), { A: DropOut, B: State_0, }, ] Note, that the 'scheme' for interval [12, 20) and [21, 255) are identical. We try to profit from it by storing only it only once. A template scheme is associated with an 'index' for reference. TemplateStates may be combined with AnalyzerStates and other TemplateStates. Thus, MegaState_Targets must be combined with trigger targets and other MegaState_Targets. NOTE: The resulting target map results from the combination of both transition maps, which may introduce new borders, e.g. |----------------| (where A triggers to X) |---------------| (where B triggers to Y) becomes |----|-----------|---| 1 2 3 where: Domain: A triggers to: B triggers to: 1 X Nothing 2 X Y 3 Nothing Y ----------------------------------------------------------------------------- Transition maps of TemplateState-s function based on 'state_keys'. Those state keys are used as indices into TemplateMegaState_Targets. The 'state_key' of a given state relates to the 'state_index' by (1) self.state_index_sequence[state_key] == state_index where 'state_index' is the number by which the state is identified inside its state machine. Correspondingly, for a given TemplateMegaState_Target T (2) T[state_key] gives the target of the template if it operates for 'state_index' determined from 'state_key' by relation (1). The state index list approach facilitates the computation of target schemes. For this reason no dictionary {state_index->target} is used. """ transition_map_tools.assert_adjacency(StateA.transition_map, TotalRangeF=True) transition_map_tools.assert_adjacency(StateB.transition_map, TotalRangeF=True) MegaState_Target.init( ) # Initialize the tracking of generated MegaState_Target-s factory = TargetFactory(StateA, StateB) result = [] for begin, end, a_target, b_target in transition_map_tools.zipped_iterable( StateA.transition_map, StateB.transition_map): target = factory.get(a_target, b_target) result.append((Interval(begin, end), target)) # Return the database of generated MegaState_Target objects mega_state_target_db = MegaState_Target.disconnect_object_db() # Number of different target schemes: scheme_n = 0 for x in (key for key in mega_state_target_db.iterkeys() if isinstance(key, tuple)): scheme_n += 1 return result, scheme_n
def combine_maps(StateA, StateB): """RETURNS: -- Transition map = combined transition map of StateA and StateB. -- List of target schemes that have been identified. NOTE: If the entries of both states are uniform, then a transition to itself of both states can be implemented as a recursion of the template state without knowing the particular states. EXPLANATION: This function combines two transition maps. A transition map is a list of tuples: [ ... (interval, target) ... ] Each tuple tells about a character range [interval.begin, interval.end) where the state triggers to the given target. In a normal AnalyzerState the target is the index of the target state. In a TemplateState, though, multiple states are combined. A TemplateState operates on behalf of a state which is identified by its 'state_key'. If two states (even TemplateStates) are combined the trigger maps are observed, e.g. Trigger Map A Trigger Map B [ [ ([0, 10), DropOut) ([0, 10), State_4) ([10, 15), State_0) ([10, 15), State_1) ([15, 20), DropOut) ([15, 20), State_0) ([20, 21), State_1) ([20, 21), DropOut) ([21, 255), DropOut) ([21, 255), State_0) ] ] For some intervals, the target is the same. But for some it is different. In a TemplateState, the intervals are associated with MegaState_Target objects. A MegaState_Target object tells the target state dependent on the 'state_key'. The above example may result in a transition map as below: Trigger Map A [ # intervals: target schemes: ( [0, 10), { A: DropOut, B: State_4, }, ( [10, 15), { A: State_0, B: State_1, }, ( [15, 20), { A: DropOut, B: State_0, }, ( [20, 21), { A: State_1, B: DropOut, }, ( [21, 255), { A: DropOut, B: State_0, }, ] Note, that the 'scheme' for interval [12, 20) and [21, 255) are identical. We try to profit from it by storing only it only once. A template scheme is associated with an 'index' for reference. TemplateStates may be combined with AnalyzerStates and other TemplateStates. Thus, MegaState_Targets must be combined with trigger targets and other MegaState_Targets. NOTE: The resulting target map results from the combination of both transition maps, which may introduce new borders, e.g. |----------------| (where A triggers to X) |---------------| (where B triggers to Y) becomes |----|-----------|---| 1 2 3 where: Domain: A triggers to: B triggers to: 1 X Nothing 2 X Y 3 Nothing Y ----------------------------------------------------------------------------- Transition maps of TemplateState-s function based on 'state_keys'. Those state keys are used as indices into TemplateMegaState_Targets. The 'state_key' of a given state relates to the 'state_index' by (1) self.state_index_sequence[state_key] == state_index where 'state_index' is the number by which the state is identified inside its state machine. Correspondingly, for a given TemplateMegaState_Target T (2) T[state_key] gives the target of the template if it operates for 'state_index' determined from 'state_key' by relation (1). The state index list approach facilitates the computation of target schemes. For this reason no dictionary {state_index->target} is used. """ transition_map_tools.assert_adjacency(StateA.transition_map, TotalRangeF=True) transition_map_tools.assert_adjacency(StateB.transition_map, TotalRangeF=True) MegaState_Target.init() # Initialize the tracking of generated MegaState_Target-s factory = TargetFactory(StateA, StateB) result = [] for begin, end, a_target, b_target in transition_map_tools.zipped_iterable(StateA.transition_map, StateB.transition_map): target = factory.get(a_target, b_target) result.append((Interval(begin, end), target)) # Return the database of generated MegaState_Target objects mega_state_target_db = MegaState_Target.disconnect_object_db() # Number of different target schemes: scheme_n = 0 for x in (key for key in mega_state_target_db.iterkeys() if isinstance(key, tuple)): scheme_n += 1 return result, scheme_n