Java Query.answer方法代碼示例

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) {
    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包/類
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包/類
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包/類
private void processQuery(
        Query<SymbolicMethodSymbol, SymbolicQueryOutput> query) {
  Word<SymbolicQueryOutput> out = getPotentialOutput(query.getInput());

  //FIXME: this has to be adapted to include dont knows!!
  for (SymbolicQueryOutput o : out) {
    if (o.isUniform() && !o.equals(SymbolicQueryOutput.OK)) {
      query.answer(o);
      return;
    }
  }
  
  this.oracle.processQueries(Collections.singleton(query));
}
 

import de.learnlib.api.Query; //導入方法依賴的package包/類
@Override
public void processQueries(Collection<? extends Query<SymbolicMethodSymbol, SymbolicQueryOutput>> clctn) {
  ArrayList<Query<SymbolicMethodSymbol, SymbolicQueryOutput>> queries
          = new ArrayList<>();
  
  for (Query<SymbolicMethodSymbol, SymbolicQueryOutput> q : clctn) {
    if (isValid(q.getInput())) {
      queries.add(q);
    }
    else {
      q.answer(SymbolicQueryOutput.ERROR);
    }
  }
  this.oracle.processQueries(queries);
}