From 68476e86f4c04212c7aae7950550869b67442c10 Mon Sep 17 00:00:00 2001
From: Kristóf Marussy <kristof@marussy.com>
Date: Fri, 29 Jul 2022 21:57:50 +0200
Subject: build: clean up buildSrc scripts

---
 .../java/tools/refinery/language/ProblemUtil.java  | 121 +++++++++++++++++++++
 1 file changed, 121 insertions(+)
 create mode 100644 subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java

(limited to 'subprojects/language/src/main')

diff --git a/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java b/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java
new file mode 100644
index 00000000..d8958381
--- /dev/null
+++ b/subprojects/language/src/main/java/tools/refinery/language/ProblemUtil.java
@@ -0,0 +1,121 @@
+package tools.refinery.language.model;
+
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.resource.Resource;
+
+import tools.refinery.language.model.problem.ClassDeclaration;
+import tools.refinery.language.model.problem.ImplicitVariable;
+import tools.refinery.language.model.problem.Node;
+import tools.refinery.language.model.problem.Problem;
+import tools.refinery.language.model.problem.ProblemPackage;
+import tools.refinery.language.model.problem.ReferenceDeclaration;
+import tools.refinery.language.model.problem.Relation;
+import tools.refinery.language.model.problem.Variable;
+
+public final class ProblemUtil {
+	public static final String BUILTIN_LIBRARY_NAME = "builtin";
+
+	public static final URI BUILTIN_LIBRARY_URI = getLibraryUri(BUILTIN_LIBRARY_NAME);
+
+	public static final String NODE_CLASS_NAME = "node";
+
+	private ProblemUtil() {
+		throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+	}
+
+	public static boolean isSingletonVariable(Variable variable) {
+		return variable.eContainingFeature() == ProblemPackage.Literals.VARIABLE_OR_NODE_ARGUMENT__SINGLETON_VARIABLE;
+	}
+	
+	public static boolean isImplicitVariable(Variable variable) {
+		return variable instanceof ImplicitVariable;
+	}
+	
+	public static boolean isImplicitNode(Node node) {
+		return node.eContainingFeature() == ProblemPackage.Literals.PROBLEM__NODES;
+	}
+	
+	public static boolean isImplicit(EObject eObject) {
+		if (eObject instanceof Node node) {
+			return isImplicitNode(node);
+		} else if (eObject instanceof Variable variable) {
+			return isImplicitVariable(variable);
+		} else {
+			return false;
+		}
+	}
+
+	public static boolean isIndividualNode(Node node) {
+		var containingFeature = node.eContainingFeature();
+		return containingFeature == ProblemPackage.Literals.INDIVIDUAL_DECLARATION__NODES
+				|| containingFeature == ProblemPackage.Literals.ENUM_DECLARATION__LITERALS;
+	}
+
+	public static boolean isNewNode(Node node) {
+		return node.eContainingFeature() == ProblemPackage.Literals.CLASS_DECLARATION__NEW_NODE;
+	}
+
+	public static Optional<Problem> getBuiltInLibrary(EObject context) {
+		return Optional.ofNullable(context.eResource()).map(Resource::getResourceSet)
+				.map(resourceSet -> resourceSet.getResource(BUILTIN_LIBRARY_URI, true)).map(Resource::getContents)
+				.filter(contents -> !contents.isEmpty()).map(contents -> contents.get(0))
+				.filter(Problem.class::isInstance).map(Problem.class::cast);
+	}
+
+	public static boolean isBuiltIn(EObject eObject) {
+		if (eObject != null) {
+			var eResource = eObject.eResource();
+			if (eResource != null) {
+				return BUILTIN_LIBRARY_URI.equals(eResource.getURI());
+			}
+		}
+		return false;
+	}
+
+	public static Optional<ClassDeclaration> getNodeClassDeclaration(EObject context) {
+		return getBuiltInLibrary(context).flatMap(problem -> problem.getStatements().stream()
+				.filter(ClassDeclaration.class::isInstance).map(ClassDeclaration.class::cast)
+				.filter(declaration -> NODE_CLASS_NAME.equals(declaration.getName())).findFirst());
+	}
+
+	public static Collection<ClassDeclaration> getSuperclassesAndSelf(ClassDeclaration classDeclaration) {
+		Set<ClassDeclaration> found = new HashSet<>();
+		getNodeClassDeclaration(classDeclaration).ifPresent(found::add);
+		Deque<ClassDeclaration> queue = new ArrayDeque<>();
+		queue.addLast(classDeclaration);
+		while (!queue.isEmpty()) {
+			ClassDeclaration current = queue.removeFirst();
+			if (!found.contains(current)) {
+				found.add(current);
+				for (Relation superType : current.getSuperTypes()) {
+					if (superType instanceof ClassDeclaration superDeclaration) {
+						queue.addLast(superDeclaration);
+					}
+				}
+			}
+		}
+		return found;
+	}
+
+	public static Collection<ReferenceDeclaration> getAllReferenceDeclarations(ClassDeclaration classDeclaration) {
+		Set<ReferenceDeclaration> referenceDeclarations = new HashSet<>();
+		for (ClassDeclaration superclass : getSuperclassesAndSelf(classDeclaration)) {
+			referenceDeclarations.addAll(superclass.getReferenceDeclarations());
+		}
+		return referenceDeclarations;
+	}
+
+	private static URI getLibraryUri(String libraryName) {
+		return URI.createURI(ProblemUtil.class.getClassLoader()
+				.getResource("model/" + libraryName + "." + ProblemEMFSetup.XMI_RESOURCE_EXTENSION)
+				.toString());
+	}
+}
-- 
cgit v1.2.3-54-g00ecf