Python Writer.set_possibilities方法代码示例

# 需要导入模块: from writer import Writer [as 别名]
# 或者: from writer.Writer import set_possibilities [as 别名]

#.........这里部分代码省略.........
        """

        # While the user enters variable values that are not allowed by
        # the transition relation of the system (if valid values are entered,
        # we jump out of the loop with a return):
        while True:
            all_outvars_bdd = BDD.ONE(self.__utils.dd_mgr)
            for out_var in self.__utils.relevant_out_vars:
                (out_bdd, quit) = self._read_single_out_var(out_var, \
                                           all_outvars_bdd * possible_outputs)
                if quit:
                    return (None, True)
                all_outvars_bdd *= out_bdd

            # check if the entered values are possible according to the
            # transition relation of the system (which is already part of
            # $possible_outputs)

            if (possible_outputs * all_outvars_bdd).isNotZero():
                return (all_outvars_bdd, False)
            print "this is not possible according to the transition relation"
            print "try again"
   

    def _read_single_out_var(self, out_var, possible_next_outputs):
        """
        Reads one single next output value from STDIN.

        This method asks the user to enter the next value of one single output
        variables of the system. It also resolves all restrictions on the
        variable (due to the transition relation of the system and previously
        entered variables) and displays possible values for the variable
        in brackets:
         - enter next hgrant0 (1): means only 1 is allowed for the next hgrant0
         - enter next hgrant0 (0): means only 0 is allowed for the next hgrant0
         - enter next hgrant0 (0,1): means that you can pick whatever you want

        The user is only allowed to enter '0', '1' or 'Q' if she wants to
        quit the game.

        @param out_var: The output variable to choose.
        @type out_var: L{Variable}
        @param possible_next_outputs: A bdd with all possible next outputs.
        @type possible_next_outputs: L{BDD}
        @return: A tuple (outvar_bdd, quit) where:
                  - outvar_bdd is a bdd with all next output variables set to
                    the values entered by the user
                  - quit is True if the user wants to quit and False otherwise.
        @rtype: (L{BDD}, int)
        """

        # while the user enteres invalid values (otherwise we jump out of
        # the loop with the return):
        while True:
            print "enter next " + out_var.name,
            self._print_possible_values_for(out_var, possible_next_outputs)
            input_line = sys.stdin.readline()

            if input_line == "Q\n" or input_line == "q\n":
                print "quit by user";
                self.__writer.write_to_file("./spec_debug_results/log.txt")
                self.__writer.clear()
                return (None, True)
            if input_line == "1\n":
                return (out_var.ns, False)
            elif input_line == "0\n":
                return (~out_var.ns, False)
            print "enter '1' or '0' or 'Q' to quit"

    def _print_possible_values_for(self, out_var, restrictions):
        """
        Prints all values which are possible for a certain output.

        This method prints all possible values for a certain output variable
        to STDOUT and also writes the values to a file
        'spec_debug_results/log.txt'.
        Writing to the file is done with the L{Writer} which formats
        the output in a nice way.

        @param out_var: The variable to print the possible values for.
        @type out_var: L{Variable}
        @param restrictions: A bdd with all restrictions on the next output
               variables.
        @type restrictions: L{BDD}
        """

        (can_be_1, can_be_0) = self.__utils.get_val(restrictions, out_var, True)

        if can_be_1 and can_be_0:
            sys.stdout.write(" (0,1): ")
            self.__writer.set_possibilities(out_var.name, "(0,1)")
        elif can_be_1:
            sys.stdout.write(" (1): ")
            self.__writer.set_possibilities(out_var.name, "( 1 )")
        elif can_be_0:
            sys.stdout.write(" (0): ")
            self.__writer.set_possibilities(out_var.name, "( 0 )")
        else:
            sys.stdout.write(" (): ")
            self.__writer.set_possibilities(out_var.name, "(   )")