예제 #1
0
파일: arule.py 프로젝트: BentleyJOakes/BDOT
class ARule(Composer):
    """
        Applies the transformation on one match.
    """

    def __init__(self, LHS, RHS):
        """
            Applies the transformation on one match.
            @param LHS: The pre-condition pattern (LHS + NACs).
            @param RHS: The post-condition pattern (RHS).
        """
        super(ARule, self).__init__()
        self.M = Matcher(condition=LHS, max=1)
        self.I = Iterator(max_iterations=1)
        self.W = Rewriter(condition=RHS)

    def packet_in(self, packet):
        self.exception = None
        self.is_success = False
        # Match
        packet = self.M.packet_in(packet)
        if not self.M.is_success:
            self.exception = self.M.exception
            return packet
        # Choose the only match
        packet = self.I.packet_in(packet)
        if not self.I.is_success:
            self.exception = self.I.exception
            return packet
        # Rewrite
        packet = self.W.packet_in(packet)
        if not self.W.is_success:
            self.exception = self.W.exception
            return packet
        # Output success packet
        self.is_success = True
        return packet
예제 #2
0
class LFRule(LRule):
    """
        Applies an inner rule for each application of the outer rule.
    """

    def __init__(self, LHS, RHS, inner_rule, outer_first, max_iterations=INFINITY):
        """
            Applies an inner rule for each application of the outer rule.
            @param LHS: The pre-condition pattern (LHS + NACs).
            @param RHS: The post-condition pattern (RHS).
            @param inner_rule: The rule to apply in the loop.
            @param outer_first: Whether the outer rule should be applied before the inner rule. 
            @param max_iterations: The maximum number of matches of the LHS.
        """
        super(LFRule, self).__init__(LHS, inner_rule, max_iterations)
        self.W = Rewriter(condition=RHS)
        self.outer_first = outer_first
        self.inner_rule = inner_rule

    def packet_in(self, packet):
        self.exception = None
        self.is_success = False
        # Match
        packet = self.M.packet_in(packet)
        if not self.M.is_success:
            self.exception = self.M.exception
            return packet
        # Choose the first match
        packet = self.I.packet_in(packet)
        if not self.I.is_success:
            self.exception = self.I.exception
            return packet
        while True:
            if self.outer_first:
                # Rewrite
                packet = self.W.packet_in(packet)
                if not self.W.is_success:
                    self.exception = self.W.exception
                    return packet
                if not self.ignore_resolver:
                    # Resolve any conflicts if necessary
                    packet = self.R.packet_in(packet)
                    if not self.R.is_success:
                        self.exception = self.R.exception
                        return packet
            # Apply the inner rule
            packet = self.inner_rule.packet_in(packet)
            if not self.inner_rule.is_success:
                self.exception = self.inner_rule.exception
                return packet
            if not self.outer_first:
                # Rewrite
                packet = self.W.packet_in(packet)
                if not self.W.is_success:
                    self.exception = self.W.exception
                    return packet
                if not self.ignore_resolver:
                    # Resolve any conflicts if necessary
                    packet = self.R.packet_in(packet)
                    if not self.R.is_success:
                        self.exception = self.R.exception
                        return packet
            # Choose another match
            packet = self.I.next_in(packet)
            # No more iterations are left
            if not self.I.is_success:
                if self.I.exception:
                    self.exception = self.I.exception
                else:
                    # Output success packet
                    self.is_success = True
                return packet
예제 #3
0
class LSRule(LRule):
    '''
        Applies an inner rule for each application of the outer rule as long as matches can be found.
    '''
    def __init__(self, LHS, RHS, inner_rule, outer_first, max_iterations=INFINITY):
        '''
            Applies an inner rule for each application of the outer rule as long as matches can be found.
            @param LHS: The pre-condition pattern (LHS + NACs).
            @param RHS: The post-condition pattern (RHS).
            @param inner_rule: The rule to apply in the loop.
            @param outer_first: Whether the outer rule should be applied before the inner rule.
            @param max_iterations: The maximum number of matches of the LHS.
        '''
        super(LSRule, self).__init__(LHS, inner_rule, max_iterations)
        self.W = Rewriter(condition=RHS)
        self.outer_first = outer_first
    
    def packet_in(self, packet):
        self.exception = None
        self.is_success = False
        # Match
        packet = self.M.packet_in(packet)
        if not self.M.is_success:
            self.exception = self.M.exception
            return packet
        # Choose the first match
        packet = self.I.packet_in(packet)
        if not self.I.is_success:
            self.exception = self.I.exception
            return packet
        while True:
            if self.outer_first:
                # Rewrite
                packet = self.W.packet_in(packet)
                if not self.W.is_success:
                    self.exception = self.W.exception
                    return packet
            # Apply the inner rule
            packet = self.inner_rule.packet_in(packet)
            if not self.inner_rule.is_success:
                self.exception = self.inner_rule.exception
                return packet
            if not self.outer_first:
                # Rewrite
                packet = self.W.packet_in(packet)
                if not self.W.is_success:
                    self.exception = self.W.exception
                    return packet
            # Rule has been applied once, so it's a success anyway
            self.is_success = True
            if self.I.iterations == self.I.max_iterations:
                return packet
            # Re-Match
            packet = self.M.packet_in(packet)
            if not self.M.is_success:
                self.exception = self.M.exception
                return packet
            # Choose another match
            packet = self.I.next_in(packet)
            # No more iterations are left
            if not self.I.is_success:
                if self.I.exception:
                    self.exception = self.I.exception
                return packet