• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env python
2# coding=utf-8
3##############################################
4# Copyright (c) 2021-2022 Huawei Device Co., Ltd.
5# Licensed under the Apache License, Version 2.0 (the "License");
6# you may not use this file except in compliance with the License.
7# You may obtain a copy of the License at
8#
9#     http://www.apache.org/licenses/LICENSE-2.0
10#
11# Unless required by applicable law or agreed to in writing, software
12# distributed under the License is distributed on an "AS IS" BASIS,
13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14# See the License for the specific language governing permissions and
15# limitations under the License.
16##############################################
17import re
18import enum
19
20
21class RangeChange(enum.Enum):
22    DOWN = 'down'
23    UP = 'up'
24    NO = 'no'
25    CHANGE = 'change'
26
27
28class CalculateValue:
29    pass_data = []
30    fail_data = []
31
32    def __init__(self):
33        self.pass_data = []
34        self.fail_data = []
35
36
37class DiffProcessorPermission:
38    # 转义规则
39    splitchar = {
40        'and': {'splitchar': 'and', 'transferchar': 'and'},
41        'or': {'splitchar': 'or', 'transferchar': 'or'},
42        'eq': {'splitchar': '=', 'transferchar': '=='},
43        'LE': {'splitchar': '->', 'transferchar': '<='},
44        'RE': {'splitchar': '<-', 'transferchar': '>='},
45        'not': {'splitchar': '-', 'transferchar': '!'},
46        'lcurve': {'splitchar': '\\(', 'transferchar': '('},
47        'rcurve': {'splitchar': '\\)', 'transferchar': ')'},
48    }
49    variable_list = []  # 命题集合
50
51    @staticmethod
52    def get_bool_in_list(number_list, bin_len):
53        state_list = [bin(i) for i in number_list]
54        state_list = [x[2:] for x in state_list]
55        state_list = ['0' * (bin_len - len(x)) + x for x in state_list]
56        state_list = [tuple([bool(eval(y)) for y in x]) for x in state_list]
57        return tuple(state_list)
58
59    @staticmethod
60    def process_value(state_value):
61        calculate = CalculateValue()
62        for state in state_value:
63            if state_value[state]:
64                calculate.pass_data.append(state)
65            else:
66                calculate.fail_data.append(state)
67        return calculate
68
69    def find_variable_list(self, string):  # return all variable_list in the string.
70        for char in self.splitchar:
71            string = re.sub(re.compile(self.splitchar[char]['splitchar']), '', string)
72        str_set = set(string.split(' '))
73        str_set.remove('')
74        variable_list = list(str_set)
75        variable_list.sort()
76        return tuple(variable_list)
77
78    def formatten(self, string):
79        for char in self.splitchar:
80            string = re.sub(re.compile(self.splitchar[char]['splitchar']), self.splitchar[char]['transferchar'], string)
81        return string
82
83    def calculate(self, string: str, variable_length: int, state_list):
84        state_value = {i: None for i in range(2 ** variable_length)}
85        for state_index in range(2 ** variable_length):
86            modify_string = string
87            for variable_index in range(variable_length):
88                modify_string = modify_string.replace(
89                    self.variable_list[variable_index], str(state_list[state_index][variable_index]))
90            state_value[state_index] = eval(modify_string)
91        return state_value
92
93    def calculate_paradigm(self, string):
94        self.variable_list = self.find_variable_list(string)
95        string = self.formatten(string)
96        variable_length = len(self.variable_list)
97        state_list = self.get_bool_in_list(range(2 ** variable_length), variable_length)
98        state_value = self.calculate(string, variable_length, state_list)
99        calculate = self.process_value(state_value)
100        return calculate
101
102    def calculate_paradigm_up(self, old_str, new_str, falg_bool=True):
103        char = ''
104        try:
105            if falg_bool:
106                char = self.splitchar['LE']['splitchar']
107            else:
108                char = self.splitchar['RE']['splitchar']
109        except KeyError:
110            print('An error occurred. The specified key does not exist.')
111        merge_str = f'({old_str}) {char} ({new_str})'
112        return self.calculate_paradigm(merge_str)
113
114
115class CalculateRsesult:
116    variable_list = []
117    state_down = []
118    state_up = []
119    state_range = ''
120
121    def __init__(self):
122        self.variable_list = []
123        self.state_down = []
124        self.state_up = []
125        self.state_range = ''
126
127
128def compare_permission(old_str, new_str):
129    permissor_tool = DiffProcessorPermission()
130    up_state = permissor_tool.calculate_paradigm_up(old_str, new_str, True)
131    down_state = permissor_tool.calculate_paradigm_up(old_str, new_str, False)
132    variable_list = permissor_tool.variable_list
133    calculate_rsesult = CalculateRsesult()
134    calculate_rsesult.variable_list = variable_list
135    if len(down_state.fail_data) > 0:
136        calculate_rsesult.state_up = permissor_tool.get_bool_in_list(down_state.fail_data, len(variable_list))
137        calculate_rsesult.state_range = RangeChange.UP.value
138    if len(up_state.fail_data) > 0:
139        calculate_rsesult.state_down = permissor_tool.get_bool_in_list(up_state.fail_data, len(variable_list))
140        if calculate_rsesult.state_range == '':
141            calculate_rsesult.state_range = RangeChange.DOWN.value
142        else:
143            calculate_rsesult.state_range = RangeChange.CHANGE.value
144    return calculate_rsesult
145