de.prob.ltl.parser.pattern.Pattern Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ltl-dsl Show documentation
Parser for a LTL Pattern DSL
There is a newer version: 0.2.2
package de.prob.ltl.parser.pattern;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.tree.ParseTree;

import de.prob.ltl.parser.LtlParser;
import de.prob.ltl.parser.WarningListener;
import de.prob.ltl.parser.semantic.PatternDefinition;


public class Pattern {

	private String name;
	private boolean builtin;
	private String description;
	private String code;
	private List definitions;
	private List errorListeners = new LinkedList();
	private List warningListeners = new LinkedList();
	private List updateListeners = new LinkedList();
	private ParseTree lastAst;
	
	public void updateDefinitions(PatternManager patternManager) {
		if (code != null) {
			if (definitions == null) {
				LtlParser parser = new LtlParser(code);
				parser.setPatternManager(patternManager);
				parser.removeErrorListeners();
				for (BaseErrorListener listener : errorListeners) {
					parser.addErrorListener(listener);
				}
				for (WarningListener listener : warningListeners) {
					parser.addWarningListener(listener);
				}

				parser.parsePatternDefinition();
				this.lastAst = parser.getAst();
				definitions = parser.getSymbolTableManager().getPatternDefinitions();
				checkPatternDefinitionNames(parser);
			}
		}
	}

	private void checkPatternDefinitionNames(LtlParser parser) {
		if (definitions != null && definitions.size() > 1) {
			String name = definitions.get(0).getSimpleName();
			boolean error = false;
			for (PatternDefinition definition : definitions) {
				if (!name.equals(definition.getSimpleName())) {
					error = true;
					break;
				}
			}
			if (error) {
				for (PatternDefinition definition : definitions) {
					parser.notifyWarningListeners(definition.getToken(), "Different pattern names in a single pattern definition.");
				}
			}
		}
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public List getSignatures() {
		List signatures = new ArrayList<>();
		for(PatternDefinition definition : definitions) {
			signatures.add(definition.getSignature());
		}
		return signatures;
	}

	public boolean isBuiltin() {
		return builtin;
	}

	public void setBuiltin(boolean builtin) {
		this.builtin = builtin;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
		definitions = null;
		notifyUpdateListeners();
	}

	public List getDefinitions() {
		return definitions;
	}

	public void addErrorListener(BaseErrorListener listener) {
		errorListeners.add(listener);
	}

	public void removeErrorListener(BaseErrorListener listener) {
		errorListeners.remove(listener);
	}

	public void removeErrorListeners() {
		errorListeners.clear();
	}

	public void addWarningListener(WarningListener listener) {
		warningListeners.add(listener);
	}

	public void removeWarningListener(WarningListener listener) {
		warningListeners.remove(listener);
	}

	public void removeWarningListeners() {
		warningListeners.clear();
	}

	public void addUpdateListener(PatternUpdateListener listener) {
		updateListeners.add(listener);
	}

	public void removeUpdateListener(PatternUpdateListener listener) {
		updateListeners.remove(listener);
	}

	public void removeUpdateListeners() {
		updateListeners.clear();
	}

	public void notifyUpdateListeners() {
		for (PatternUpdateListener listener: updateListeners) {
			listener.patternUpdated(this, null);
		}
	}
	
	public ParseTree getAst() {
		return lastAst;
	}

}