Java Query类代码示例

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public final void processQueries(
        Collection<? extends Query<SymbolicMethodSymbol, Boolean>> clctn) {
  
  ArrayList<Query<SymbolicMethodSymbol, Boolean>> queries = new ArrayList<>();
  for (Query<SymbolicMethodSymbol, Boolean> q : clctn) {
    boolean test = evaluateQuery(q);
    if (!test) {
      q.answer(false);
      continue;
    }
    
    if (next == null) {
      q.answer(true);
      continue;
    }
    
    queries.add(q);
  }
  
  if (!queries.isEmpty()) {
    next.processQueries(queries);
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
private void processQuery(
        Query<SymbolicMethodSymbol, SymbolicQueryOutput> query) {
  Word<SymbolicQueryOutput> out = getPotentialOutput(query.getInput());
  int uniformIdx = getUniformIndex(out);
  if (uniformIdx == 0) {
    query.answer(SymbolicQueryOutput.OK);
    return;
  }
    
  if (uniformIdx == out.length()) {
    this.oracle.processQueries(Collections.singleton(query));
    return;
  }
  
  Word<SymbolicMethodSymbol> prefix = query.getInput().prefix(uniformIdx);
  DefaultQuery<SymbolicMethodSymbol, SymbolicQueryOutput> dQuery = 
          new DefaultQuery<>(prefix);
  
  this.oracle.processQueries(Collections.singleton(dQuery));
  query.answer(dQuery.getOutput());
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends Query<I, Word<D>>> queries) {
	for (Query<I,Word<D>> q : queries) {
		Word<D> output = answerQuery(q.getPrefix(), q.getSuffix());
		q.answer(output);
	}
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends Query<SymbolicMethodSymbol, SymbolicExecutionResult>> clctn) {
  for (Query<SymbolicMethodSymbol, SymbolicExecutionResult> query : clctn) {
    SymbolicExecutionResult result = processQuery(query.getInput());
    query.answer(result);
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends 
        Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> query : clctn) {
    if (termination.isDone()) {
      throw new Terminate(termination);
    }
    this.oracle.processQueries(Collections.singleton(query));
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {
  ArrayList<WrapperQuery> queries = new ArrayList<>();
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> q : clctn) {
    queries.add(new WrapperQuery(q));
  }
  this.oracle.processQueries(queries);
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends 
        Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> query : clctn) {
    DefaultQuery<SymbolicMethodSymbol, SymbolicQueryOutput> _query = 
            new DefaultQuery<>(query.getInput());
    this.oracle.processQueries(Collections.singleton(_query));
    if (!_query.getOutput().isUniform()) {
      throw new RefinementNeeded(_query);
    }
    query.answer(_query.getOutput());
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(
        Collection<? extends 
              Query<SymbolicMethodSymbol, SymbolicExecutionResult>> clctn) {
  for (Query<SymbolicMethodSymbol, SymbolicExecutionResult> query : clctn) {
    processQuery(query);
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
private void processQuery(
        Query<SymbolicMethodSymbol, SymbolicExecutionResult> query) {
  
  ArrayList<Path> ok  = new ArrayList<>(); 
  ArrayList<Path> err = new ArrayList<>(); 
  ArrayList<Path> dk  = new ArrayList<>(); 
  
  Collection<PathQuery> paths = PathUtil.explode(query.getInput(), inputs);
  for (PathQuery q : paths) {      
    Path p = PathUtil.executeSymbolically(
            q.getMethods(), q.getPaths(), inputs.getInitialValuation());
    
    // TODO: maybe add model to path 
    if (!sat(p.getPathCondition())) {
      continue;
    }
    switch (p.getState()) {
      case OK:
        ok.add(p);
        break;
      case ERROR:
        err.add(p);
        break;
      case DONT_KNOW:
        dk.add(p);
        break;
    }
  }
  
  query.answer(new SymbolicExecutionResult(ok, err, dk));
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends Query<SymbolicMethodSymbol,
        SymbolicQueryOutput>> clctn) {
  Collection<Query<SymbolicMethodSymbol, SymbolicQueryOutput>> lCol =
          new ArrayList<>();
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> query : clctn) {
    lCol.add(new LoggingQuery(query));
  }
  this.oracle.processQueries(lCol);
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(
        Collection<? extends 
                Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {

  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> q : clctn) {
    processQuery(q);
  }
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
private void processQuery(Query<SymbolicMethodSymbol,
        SymbolicQueryOutput> q) {
 String[] test = queryToString(q.getInput());
 SymbolicQueryOutput result = table.getSimulatedResult(test);
 if (result == null) {
   DefaultQuery<SymbolicMethodSymbol, SymbolicQueryOutput> defq =
          new DefaultQuery<>(q.getInput());
   
   this.oracle.processQueries(Collections.singleton(defq));
   
   result = defq.getOutput();
   table.setResult(test, result);
 } 
 q.answer(result);   
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
private void processQuery(Query<SymbolicMethodSymbol,
        SymbolicQueryOutput> query) {
  Word<SymbolicMethodSymbol> sEps = Word.epsilon();
  Word<Path> pEps = Word.epsilon();    
  ExecutionTree tree = new ExecutionTree(pEps, sEps, query.getInput());
  query.answer(tree.getOutput());
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public boolean evaluateQuery(Query<SymbolicMethodSymbol, Boolean> query) {
  Word<SymbolicMethodSymbol> input = query.getInput();
  // constructor + 1 will always be executed
  if (input.size() < 3) {
    return false;
  }

  String lastName = input.getSymbol(1).getConcolicMethodConfig().getId();
  Pair<BitSet,BitSet> lastMethod = po.get(lastName);
  for (int i=2; i<input.size(); i++) {      
    String curName = input.getSymbol(i).getConcolicMethodConfig().getId();
    Pair<BitSet,BitSet> cur = po.get(curName); 

    if (cur != null && lastMethod != null) {
      if (curName.compareTo(lastName) < 0
              && !lastMethod._1.intersects(cur._2) // read-write
              && !lastMethod._2.intersects(cur._1) // write-read
              && !lastMethod._2.intersects(cur._2) // write-write
            ) {
        return false;
      }
    }

    lastName = curName;
    lastMethod = cur;
  }
  return true;
}
 

import de.learnlib.api.Query; //导入依赖的package包/类
@Override
public void processQueries(Collection<? extends 
        Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> query : clctn) {
    processQuery(query);
  }
}