added more api template classe

-> TODO:
(1) Add CoPattern template
(2) Implement: rule application
(3) Implement: match conditions
(4) Implement: Match filter

org.emoflon.ibex.gt/src/org/emoflon/ibex/gt/build/template/IBeXGTApiData.java

@@ -33,6 +33,8 @@ public class IBeXGTApiData {
 	final public Map<GTPattern, String> pattern2matchClassName = new LinkedHashMap<>();
 	final public Map<GTPattern, String> pattern2patternClassName = new LinkedHashMap<>();
 	final public Map<GTRule, String> rule2ruleClassName = new LinkedHashMap<>();
+	final public Map<GTRule, String> rule2CoPatternClassName = new LinkedHashMap<>();
+	final public Map<GTRule, String> rule2CoMatchClassName = new LinkedHashMap<>();
 	final public Map<GTPattern, GTRule> pattern2rule = new LinkedHashMap<>();
 
 	public IBeXGTApiData(final GTModel model) {
@@ -65,6 +67,8 @@ protected void init() {
 			rulePatterns.add((GTPattern) rule.getPrecondition());
 			rule2ruleClassName.put(rule, firstToUpper(rule.getName()) + "Rule");
 			pattern2matchClassName.put((GTPattern) rule.getPrecondition(), firstToUpper(rule.getName()) + "Match");
+			rule2CoPatternClassName.put(rule, firstToUpper(rule.getPostcondition().getName()));
+			rule2CoMatchClassName.put(rule, firstToUpper(rule.getName()) + "CoMatch");
 			pattern2rule.put((GTPattern) rule.getPrecondition(), rule);
 		});
 		model.getPatternSet().getPatterns().stream().map(pattern -> (GTPattern) pattern)

org.emoflon.ibex.gt/src/org/emoflon/ibex/gt/build/template/IBeXGtCoMatchTemplate.xtend

@@ -0,0 +1,128 @@
+package org.emoflon.ibex.gt.build.template
+
+import org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTPattern
+import org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTRule
+
+class IBeXGtCoMatchTemplate extends GeneratorTemplate<GTRule>{
+
+	protected String ruleClassName;
+	protected String matchClassName;
+	protected String coPatternClassName;
+	protected GTPattern coPattern;
+
+	new(IBeXGTApiData data, GTRule context) {
+		super(data, context)
+	}
+
+	override init() {
+		packageName = data.matchPackage
+		className = data.rule2CoMatchClassName.get(context)
+		fqn = packageName + "." + className;
+		filePath = data.matchPackagePath + "/" + className
+
+		imports.add("java.util.List")
+		imports.add("java.util.Map")
+		imports.add("org.emoflon.ibex.common.operational.HashUtil")
+		imports.add("org.emoflon.ibex.gt.engine.IBeXGTCoMatch")
+		ruleClassName = data.rule2ruleClassName.get(context);
+		matchClassName = data.pattern2matchClassName.get(context.precondition)
+		coPatternClassName = data.rule2CoPatternClassName.get(context)
+
+		imports.add(data.rulePackage + "." + ruleClassName)
+		imports.add(data.patternPackage + "." + coPatternClassName)
+		imports.add(data.matchPackage + "." + matchClassName)
+
+		coPattern = context.postcondition as GTPattern
+		coPattern.signatureNodes
+			.map[node | data.model.metaData.name2package.get(node.eClass.EPackage.name).classifierName2FQN.get(node.type)]
+			.forEach[fqn | imports.add(fqn)]
+	}
+
+	override generate() {
+		code = '''package «data.matchPackage»
+
+«FOR imp : imports»
+import «imp»;
+«ENDFOR»
+
+public class «className» extends IBeXGTCoMatch<«className», «coPatternClassName», «ruleClassName», «ruleClassName», «matchClassName»> {
+
+	«FOR node : coPattern.signatureNodes»
+	protected «node.type.name» «node.name.toFirstLower»;
+	«ENDFOR»
+
+	public «className»(final «ruleClassName» typedRule, final «coPatternClassName» typedCoPattern, final Map<String, Object> nodes) {
+		super(typedRule, typedCoPattern, nodes);
+	}
+
+	public «className»(final «className» other) {
+		super(other);
+	}
+
+	@Override
+	public String getPatternName() {
+		return "«context.name»"	
+	}
+
+	@Override
+	public Object get(String name) {
+		return switch(name) -> {
+			«FOR node : coPattern.signatureNodes»
+			case "«node.name»" -> yield «node.name.toFirstLower»
+			«ENDFOR»
+		};
+	}
+
+	@Override
+	public Collection<String> getParameterNames() {
+		return List.of(
+			«FOR node : coPattern.signatureNodes SEPARATOR ', '» 
+			"«node.name»"
+			«ENDFOR»
+		);
+	}
+
+	@Override
+	public Collection<Object> getObjects() {
+		return List.of(
+			«FOR node : coPattern.signatureNodes SEPARATOR ', '» 
+			«node.name.toFirstLower»
+			«ENDFOR»
+		);
+	}
+
+	@Override
+	protected void initialize(final Map<String, Object> nodes) {
+		«FOR node : coPattern.signatureNodes»
+		«node.name.toFirstLower» = («node.type.name») nodes.get("«node.name»");
+		«ENDFOR»
+	}
+
+	@Override
+	protected void initialize(final «className» other) {
+		«FOR node : coPattern.signatureNodes»
+		«node.name.toFirstLower» = other.«node.name.toFirstLower»;
+		«ENDFOR»
+	}
+
+	@Override
+	public boolean checkConditions() {
+		return typedPattern.checkConditions(this);
+	}
+
+	@Override
+	public «className» copy() {
+		return new «className»(this);
+	}
+
+	«FOR node : coPattern.signatureNodes»
+	public «node.type.name» «node.name.toFirstLower»() {
+		return «node.name.toFirstLower»;
+	}
+
+	«ENDFOR»
+}'''
+	}
+
+
+}

org.emoflon.ibex.gt/src/org/emoflon/ibex/gt/build/template/IBeXGtMatchTemplate.xtend

@@ -35,7 +35,7 @@ class IBeXGtMatchTemplate extends GeneratorTemplate<GTPattern>{
 	}
 
 	override generate() {
-		code = '''package data.matchPackage
+		code = '''package «data.matchPackage»
 
 «FOR imp : imports»
 import «imp»;

org.emoflon.ibex.gt/src/org/emoflon/ibex/gt/build/template/IBeXGtPatternTemplate.xtend

@@ -0,0 +1,78 @@
+package org.emoflon.ibex.gt.build.template
+
+import org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTPattern
+
+class IBeXGtPatternTemplate extends GeneratorTemplate<GTPattern>{
+
+	protected String matchClassName;
+
+	new(IBeXGTApiData data, GTPattern context) {
+		super(data, context)
+	}
+
+	override init() {
+		packageName = data.patternPackage
+		className = data.pattern2patternClassName.get(context)
+		matchClassName = data.pattern2matchClassName.get(context)
+
+		fqn = packageName + "." + className;
+		filePath = data.patternPackagePath + "/" + className
+
+		imports.add("java.util.Collection")
+		imports.add("java.util.Map")
+		imports.add("org.emoflon.ibex.gt.engine.IBeXGTPattern")
+		imports.add("org.emoflon.ibex.gt.api.IBeXGtAPI")
+		imports.add("org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTPattern")
+
+	}
+
+	override generate() {
+		code = '''package «data.patternPackage»
+
+«FOR imp : imports»
+import «imp»;
+«ENDFOR»
+
+public class «className» extends IBeXGTPattern<«className», «matchClassName»> {
+
+	public «className»(final IBeXGtAPI<?, ?, ?> api, final GTPattern pattern) {
+		super(api, pattern);
+	}
+
+	@Override
+	protected Collection<String> getParameterNames() {
+		throw new UnsupportedOperationException("Patterns do not have any parameters.");
+	}
+
+	@Override
+	protected Map<String, Object> getParameters() {
+		throw new UnsupportedOperationException("Patterns do not have any parameters.");
+	}
+
+	@Override
+	protected boolean checkConditions(final «matchClassName» match) {
+		//TODO: !
+		return false;
+	}
+
+	@Override
+	public boolean hasArithmeticExpressions() {
+		//TODO: !
+		return false;
+	}
+
+	@Override
+	public abstract boolean hasCountExpressions() {
+		//TODO: !
+		return false;
+	}
+
+	protected «matchClassName» createMatch(final Map<String, Object> nodes) {
+		return new «matchClassName»(this, nodes);
+	}
+
+}'''
+	}
+
+
+}

org.emoflon.ibex.gt/src/org/emoflon/ibex/gt/build/template/IBeXGtRuleTemplate.xtend

@@ -0,0 +1,149 @@
+package org.emoflon.ibex.gt.build.template
+
+import org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTRule
+
+class IBeXGtRuleTemplate extends GeneratorTemplate<GTRule>{
+
+	protected String coMatchClassName;
+	protected String matchClassName;
+
+	protected String coPatternClassName;
+	protected String patternClassName;
+
+	new(IBeXGTApiData data, GTRule context) {
+		super(data, context)
+	}
+
+	override init() {
+		packageName = data.rulePackage
+		className = data.rule2ruleClassName.get(context)
+		coMatchClassName = data.rule2CoMatchClassName.get(context)
+		matchClassName = data.pattern2matchClassName.get(context.precondition)
+		coPatternClassName = data.rule2CoPatternClassName.get(context)
+		patternClassName = data.pattern2patternClassName.get(context.precondition)
+
+		fqn = packageName + "." + className;
+		filePath = data.rulePackagePath + "/" + className
+
+		imports.add("java.util.Collection")
+		imports.add("java.util.List")
+		imports.add("java.util.Map")
+		imports.add("java.util.Optional")
+		imports.add("org.emoflon.ibex.gt.engine.IBeXGTRule")
+		imports.add("org.emoflon.ibex.gt.api.IBeXGtAPI")
+		imports.add("org.emoflon.ibex.gt.gtmodel.IBeXGTModel.GTRule")
+
+		context.parameters
+			.map[param | data.model.metaData.name2package.get(param.type.EPackage).classifierName2FQN.get(param.type.name)]
+			.forEach[fqn | imports.add(fqn)]
+
+	}
+
+	override generate() {
+		code = '''package «data.rulePackage»
+
+«FOR imp : imports»
+import «imp»;
+«ENDFOR»
+
+public class «className» extends IBeXGTRule<«className», «patternClassName», «matchClassName», «coPatternClassName», «coMatchClassName»> {
+
+	«FOR param : context.parameters»
+	protected «param.type.name» «param.name.toFirstLower»;
+	«ENDFOR»
+
+	public «className»(final IBeXGtAPI<?, ?, ?> api, final GTRule rule) {
+		super(api, rule);
+	}
+
+	@Override
+	protected Collection<String> getParameterNames() {
+		return List.of(
+			«FOR param : context.parameters SEPARATOR ', '»
+			"«param.name»"
+			«ENDFOR»
+		);
+	}
+
+	@Override
+	protected Map<String, Object> getParameters() {
+		return Map.of(
+			«FOR param : context.parameters SEPARATOR ', '»
+			"«param.name»", «param.name.toFirstLower»
+			«ENDFOR»
+		);
+	}
+
+	@Override
+	public void setParameters(final Map<String, Object> parameters) {
+		for(String name : parameters.keySet()) {
+			switch(name) {
+				«FOR param : context.parameters»
+				case "«param.name»" : {
+					«param.name.toFirstLower» = parameters.get("«param.name»");
+					break;
+				}
+				«ENDFOR»
+			}
+		}
+	}
+
+	public void setParameters(«FOR param : context.parameters SEPARATOR ', '»final «param.type.name» «param.name.toFirstLower»«ENDFOR») {
+		«FOR param : context.parameters»
+		this.«param.name.toFirstLower» = «param.name.toFirstLower»;
+		«ENDFOR»
+	}
+
+	@Override
+	protected boolean checkConditions(final «matchClassName» match) {
+		//TODO: !
+		return false;
+	}
+
+	@Override
+	public boolean hasArithmeticExpressions() {
+		//TODO: !
+		return false;
+	}
+
+	@Override
+	public abstract boolean hasCountExpressions() {
+		//TODO: !
+		return false;
+	}
+
+	protected «matchClassName» createMatch(final Map<String, Object> nodes) {
+		return new «matchClassName»(this, nodes);
+	}
+
+	protected «coPatternClassName» createCoPattern() {
+		return new «coPatternClassName»(api, this, rule);
+	}
+
+	public boolean hasProbability() {
+		«IF context.probability === null»
+		return false;
+		«ELSE»
+		return true;
+		«ENDIF»
+	}
+
+	public double getProbability(final «matchClassName» match) {
+		// TODO: !
+		return 0.0;
+	}
+
+	public Optional<«coMatchClassName»> apply(final «matchClassName» match) {
+		// TODO: !
+		return Optional.empty();
+	}
+
+	public Optional<«matchClassName»> applyReverse(final «coMatchClassName» coMatch) {
+		throw new UnsupportedOperationException("Reverse application is currently not implemented!");
+	}
+
+}'''
+	}
+
+
+}