示例#1
0
  public boolean resolveResolutions() {
    ArrayList<Resolution> resolutions = mResolutions;
    mResolutions = new ArrayList<Resolution>();

    boolean allResolved = true;
    for (Resolution resolution : resolutions) {
      StringBuilder qualifiedClassName = new StringBuilder();
      InfoBuilder.resolveQualifiedName(
          resolution.getValue(), qualifiedClassName, resolution.getInfoBuilder());

      // if we still couldn't resolve it, save it for the next pass
      if ("".equals(qualifiedClassName.toString())) {
        mResolutions.add(resolution);
        allResolved = false;
      } else if ("thrownException".equals(resolution.getVariable())) {
        mThrownExceptions.add(InfoBuilder.Caches.obtainClass(qualifiedClassName.toString()));
      }
    }

    return allResolved;
  }
示例#2
0
  public static void main(String[] args) throws Exception {
    LinkedList<Clause> clauses = new LinkedList<Clause>(); // the list of the clauses

    // Read files and add the corresponding clauses to the linkedlist
    // call the resolution function on each clause against all other clauses above it. start with
    // the clause on the bottom. O(n^2) calls.
    // each resolution call may add new clauses to the linked list. to avoid redundant resolution
    // calls and thus prevent infinite loops, use a stack to determine which clause will be calling
    // the resolution function next
    // To implement, compare the size of the new linkedlist to the old linkedlist. if the sizes are
    // different (the new linkedlist has a new clause), then add the ID of the new clause(s) to the
    // stack
    // Example, linkedlist - before: <1 2 3>, after <1 2 3 4>. We would add 4 to the stack. Assuming
    // 4 was added after resolving clause 3, the stack would be <4 2 1>, so we would resolve 4 next.
    // We stop when the resolution function returns "false", which means that the resolution found
    // contradicting clauses. Otherwise, if the loop continues to completion, then every clause has
    // been tested.
    // At this point, we return failure.

    BufferedReader fileReader;

    if (args.length != 1) {
      System.out.println("Wrong input parameters!");
      System.out.println("Format:");
      System.out.println("java Resolution <inputfile>");
      System.exit(0);
    }

    fileReader = new BufferedReader(new FileReader(args[0]));
    String line = fileReader.readLine();
    int clauseCount = 1;

    while (line != null) {
      String[] literals = line.split(" ");
      boolean[] literalValuesNegated = new boolean[literals.length];

      for (int literalCount = 0; literalCount < literals.length; literalCount++) {
        if (literals[literalCount].charAt(0) == '~') {
          literals[literalCount] = literals[literalCount].substring(1);
          literalValuesNegated[literalCount] = true;
        } else {
          literalValuesNegated[literalCount] = false;
        }
      }

      clauses.add(new Clause(clauseCount, literals, literalValuesNegated));
      clauseCount++;
      line = fileReader.readLine();
    }

    /*String[] testString1 = {"z", "y", "x"};
    String[] testString2 = {"y", "z", "x"};
    boolean[] testBool1 = {true, false, true};
    boolean[] testBool2 = {true, true, true};
    Clause testClause1 = new Clause(1, testString1, testBool1);
    Clause testClause2 = new Clause(2, testString2, testBool2);
    testClause1.resolution(testClause2, clauses);
    Clause resultClause = clauses.getFirst();
    resultClause.outputClause();
    String[] testString3 = {"z"};
    String[] testString4 = {"z"};
    boolean[] testBool3 = {false};
    boolean[] testBool4 = {true};
    Clause testClause3 = new Clause(3, testString3, testBool3);
    Clause testClause4 = new Clause(4, testString4, testBool4);
    testClause3.resolution(testClause4, clauses);
    resultClause = clauses.get(1);
    resultClause.outputClause();
    System.out.println("End");*/

    /*String[] testString1 = {"z", "y", "x"};
    String[] testString2 = {"y", "z", "x"};
    boolean[] testBool1 = {true, false, true};
    boolean[] testBool2 = {true, true, true};
    clauses.add(new Clause(1, testString1, testBool1));
    clauses.add(new Clause(2, testString2, testBool2));*/

    /*String[] testString1 = {"z"};
    String[] testString2 = {"z"};
    boolean[] testBool1 = {true};
    boolean[] testBool2 = {false};
    clauses.add(new Clause(1, testString1, testBool1));
    clauses.add(new Clause(2, testString2, testBool2));*/

    Resolution resolution = new Resolution();
    if (!resolution.resolve(clauses)) // if the resolution results in false being generated
    {
      resolution.printProofTree(clauses.getLast(), clauses);
    } else {
      System.out.println("Failure");
    }
    System.out.println("Size of final clause set:   " + clauses.size());
  }
 /**
  * Asynchronously sends a message to multiple servers, potentially multiple times, registering a
  * listener to receive a callback on success or exception. Multiple asynchronous lookups can be
  * performed in parallel. Since the callback may be invoked before the function returns, external
  * synchronization is necessary.
  *
  * @param query The query to send
  * @param listener The object containing the callbacks.
  * @return An identifier, which is also a parameter in the callback
  */
 public Object sendAsync(final Message query, final ResolverListener listener) {
   Resolution res = new Resolution(this, query);
   res.startAsync(listener);
   return res;
 }
 /**
  * Sends a message and waits for a response. Multiple servers are queried, and queries are sent
  * multiple times until either a successful response is received, or it is clear that there is no
  * successful response.
  *
  * @param query The query to send.
  * @return The response.
  * @throws IOException An error occurred while sending or receiving.
  */
 public Message send(Message query) throws IOException {
   Resolution res = new Resolution(this, query);
   return res.start();
 }