Java SUL类代码示例

import de.learnlib.api.SUL; //导入依赖的package包/类
public void loadEquivalenceAlgorithm(String algorithm, SimpleAlphabet<String> alphabet, SUL<String, String> sul) throws Exception {
	//TODO We could combine the two cached oracle to save some queries to the SUL
	// Create the equivalence oracle
	//eqOracle = new SULOracle<String, String>(sul);
	// Add a logging oracle
	logEqOracle = new MealyLogOracle<String, String>(sul, LearnLogger.getLogger("equivalence_queries"));
	// Add an oracle that counts the number of queries
	statsEqOracle = new MealyCounterOracle<String, String>(logEqOracle, "equivalence queries to SUL");
	// Use cache oracle to prevent double queries to the SUL
	//cachedEqOracle = MealyCacheOracle.createDAGCacheOracle(alphabet, statsEqOracle);
       // Count the number of queries to the cache
	statsCachedEqOracle = new MealyCounterOracle<String, String>(statsEqOracle, "equivalence queries to cache");
	
	// Instantiate the selected equivalence algorithm
	switch(algorithm.toLowerCase()) {
		case "wmethod":
			equivalenceAlgorithm = new WMethodEQOracle.MealyWMethodEQOracle<String, String>(config.max_depth, statsCachedEqOracle);
			break;

		case "modifiedwmethod":
			equivalenceAlgorithm = new MealyModifiedWMethodEQOracle<String, String>(config.max_depth, statsCachedEqOracle);
			break;
			
		case "wpmethod":
			equivalenceAlgorithm = new WpMethodEQOracle.MealyWpMethodEQOracle<String, String>(config.max_depth, statsCachedEqOracle);
			break;
			
		case "randomwords":
			equivalenceAlgorithm = new MealyRandomWordsEQOracle<String, String>(statsCachedEqOracle, config.min_length, config.max_length, config.nr_queries, new Random(config.seed));
			break;
			
		default:
			throw new Exception("Unknown equivalence algorithm " + config.eqtest);
	}	
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public StepCounterSUL(SUL<Symbol, String> actualSUL){
	this.actualSUL = actualSUL;
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public TestTrackingSUL(SUL<Symbol, String> actualSUL) {
	this.actualSUL = actualSUL;
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public SUL<String, String> fork() throws UnsupportedOperationException {
	throw new UnsupportedOperationException("Cannot fork SocketSUL");
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public SUL<String, String> fork() throws UnsupportedOperationException {
	throw new UnsupportedOperationException("Cannot fork SCSUL");
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public MealyLogOracle(SUL<I, O> sul, LearnLogger logger) {
	super(sul, logger);
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public LogOracle(SUL<I,D> sul, LearnLogger logger) {        
    this.sul = sul;
    this.logger = logger;
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
public void loadLearningAlgorithm(String algorithm, SimpleAlphabet<String> alphabet, SUL<String, String> sul) throws Exception {
	// Create the membership oracle
	//memOracle = new SULOracle<String, String>(sul);
	// Add a logging oracle
	logMemOracle = new MealyLogOracle<String, String>(sul, LearnLogger.getLogger("learning_queries"));		
       // Count the number of queries actually sent to the SUL
	statsMemOracle = new MealyCounterOracle<String, String>(logMemOracle, "membership queries to SUL");
	// Use cache oracle to prevent double queries to the SUL
	//cachedMemOracle = MealyCacheOracle.createDAGCacheOracle(alphabet, statsMemOracle);
       // Count the number of queries to the cache
	statsCachedMemOracle = new MealyCounterOracle<String, String>(statsMemOracle, "membership queries to cache");
	
	// Instantiate the selected learning algorithm
	switch(algorithm.toLowerCase()) {
		case "lstar":
			learningAlgorithm = new ExtensibleLStarMealyBuilder<String, String>().withAlphabet(alphabet).withOracle(statsCachedMemOracle).create();
			break;
			 	
		case "dhc":
			learningAlgorithm = new MealyDHC<String, String>(alphabet, statsCachedMemOracle);
			break;
			
		case "kv":
			learningAlgorithm = new KearnsVaziraniMealy<String, String>(alphabet, statsCachedMemOracle, true, AcexAnalyzers.BINARY_SEARCH);
			break;
			
		case "ttt":
			AcexLocalSuffixFinder suffixFinder = new AcexLocalSuffixFinder(AcexAnalyzers.BINARY_SEARCH, true, "Analyzer");
			learningAlgorithm = new TTTLearnerMealy<String, String>(alphabet, statsCachedMemOracle, suffixFinder);
			break;
			
		case "mp":
			learningAlgorithm = new MalerPnueliMealy<String, String>(alphabet, statsCachedMemOracle);
			break;
			
		case "rs":
			learningAlgorithm = new RivestSchapireMealy<String, String>(alphabet, statsCachedMemOracle);
			break;

		default:
			throw new Exception("Unknown learning algorithm " + config.learning_algorithm);
	}		
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
/**
 * @param inputSUL
 *         The SUL that will handle the actual requests.
 */
public AlexSUL(SUL<I, O> inputSUL) {
    this.inputSUL = inputSUL;
    resetCounter();
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
@Nonnull
@Override
public SUL<I, O> fork() throws UnsupportedOperationException {
    return symbolCounterSUL.fork();
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param user
 * @param learnerResultDAO {@link #learnerResultDAO}.
 * @param context          The context to use.
 * @param result           {@link #result}.
 * @param configuration    {@link #configuration}.
 */
public AbstractLearnerThread(User user, LearnerResultDAO learnerResultDAO,
                             ConnectorContextHandler context,
                             LearnerResult result,
                             T configuration) {
    this.user = user;
    this.learnerResultDAO = learnerResultDAO;
    this.result = result;
    this.configuration = configuration;
    this.abstractAlphabet = new SimpleAlphabet<>(
            result.getSymbols().stream()
                    .map(Symbol::getName)
                    .sorted(String::compareTo)
                    .collect(Collectors.toList())
    );

    this.finished = false;
    this.maxConcurrentQueries = context.getMaxConcurrentQueries();
    this.currentQueries = new ArrayList<>();

    // prepare the mapped sul.
    symbolMapper = new SymbolMapper(result.getSymbols());
    final ContextExecutableInputSUL<ContextExecutableInput<ExecuteResult, ConnectorManager>, ExecuteResult, ConnectorManager>
            ceiSUL = new ContextExecutableInputSUL<>(context);
    final SUL<String, String> mappedSUL = SULMappers.apply(symbolMapper, ceiSUL);
    this.sul = new AlexSUL<>(mappedSUL);

    this.multiSULOracle = new MultiSULOracle<>(sul);

    // monitor which queries are being processed.
    monitorOracle = new QueryMonitorOracle<>(multiSULOracle);
    monitorOracle.addPostProcessingListener(queries -> {
        List<DefaultQueryProxy> currentQueries = new ArrayList<>();
        queries.forEach(query -> currentQueries.add(DefaultQueryProxy.createFrom(new DefaultQuery<>(query))));
        this.currentQueries = currentQueries;
    });

    // create the concrete membership oracle.
    this.mqOracle = new DelegationOracle<>();
    if (result.isUseMQCache()) {
        this.mqOracle.setDelegate(MealyCacheOracle.createDAGCacheOracle(this.abstractAlphabet, monitorOracle));
    } else {
        this.mqOracle.setDelegate(monitorOracle);
    }

    // create the learner.
    this.learner = result.getAlgorithm().createLearner(abstractAlphabet, mqOracle);
}
 

import de.learnlib.api.SUL; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param sul The sul the membership queries should be posed to.
 */
public MultiSULOracle(SUL<I, O> sul) {
    this.sul = sul;
}