1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/*
* SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
*
* SPDX-License-Identifier: EPL-2.0
*/
package tools.refinery.generator;
import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.xtext.diagnostics.Severity;
import org.eclipse.xtext.resource.FileExtensionProvider;
import org.eclipse.xtext.resource.IResourceFactory;
import org.eclipse.xtext.resource.XtextResourceSet;
import org.eclipse.xtext.util.LazyStringInputStream;
import org.eclipse.xtext.validation.CheckMode;
import org.eclipse.xtext.validation.IResourceValidator;
import tools.refinery.language.model.problem.Problem;
import tools.refinery.language.model.problem.Relation;
import tools.refinery.language.model.problem.ScopeDeclaration;
import tools.refinery.store.util.CancellationToken;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
public class ProblemLoader {
private String fileExtension;
@Inject
private Provider<XtextResourceSet> resourceSetProvider;
@Inject
private IResourceFactory resourceFactory;
@Inject
private IResourceValidator resourceValidator;
private CancellationToken cancellationToken = CancellationToken.NONE;
@Inject
public void setFileExtensionProvider(FileExtensionProvider fileExtensionProvider) {
this.fileExtension = fileExtensionProvider.getPrimaryFileExtension();
}
public ProblemLoader cancellationToken(CancellationToken cancellationToken) {
this.cancellationToken = cancellationToken;
return this;
}
public Problem loadString(String problemString, URI uri) throws IOException {
try (var stream = new LazyStringInputStream(problemString)) {
return loadStream(stream, uri);
}
}
public Problem loadString(String problemString) throws IOException {
return loadString(problemString, null);
}
public Problem loadStream(InputStream inputStream, URI uri) throws IOException {
var resourceSet = resourceSetProvider.get();
var resourceUri = uri == null ? URI.createFileURI("__synthetic." + fileExtension) : uri;
var resource = resourceFactory.createResource(resourceUri);
resourceSet.getResources().add(resource);
resource.load(inputStream, Map.of());
return loadResource(resource);
}
public Problem loadStream(InputStream inputStream) throws IOException {
return loadStream(inputStream, null);
}
public Problem loadFile(File file) throws IOException {
return loadFile(file.getAbsolutePath());
}
public Problem loadFile(String filePath) throws IOException {
return loadUri(URI.createFileURI(filePath));
}
public Problem loadUri(URI uri) throws IOException {
var resourceSet = resourceSetProvider.get();
var resource = resourceFactory.createResource(uri);
resourceSet.getResources().add(resource);
resource.load(Map.of());
return loadResource(resource);
}
public Problem loadResource(Resource resource) {
var issues = resourceValidator.validate(resource, CheckMode.ALL, () -> {
cancellationToken.checkCancelled();
return Thread.interrupted();
});
cancellationToken.checkCancelled();
var errors = issues.stream()
.filter(issue -> issue.getSeverity() == Severity.ERROR)
.toList();
if (!errors.isEmpty()) {
throw new ValidationErrorsException(resource.getURI(), errors);
}
if (resource.getContents().isEmpty() || !(resource.getContents().getFirst() instanceof Problem problem)) {
throw new IllegalArgumentException("Model generation problem not found in resource " + resource.getURI());
}
return problem;
}
public Problem loadScopeConstraints(Problem problem, List<String> extraScopes,
List<String> overrideScopes) throws IOException {
var allScopes = new ArrayList<>(extraScopes);
allScopes.addAll(overrideScopes);
if (allScopes.isEmpty()) {
return problem;
}
int originalStatementCount = problem.getStatements().size();
var builder = new StringBuilder();
var problemResource = problem.eResource();
try (var outputStream = new ByteArrayOutputStream()) {
problemResource.save(outputStream, Map.of());
builder.append(outputStream.toString(StandardCharsets.UTF_8));
}
builder.append('\n');
for (var scope : allScopes) {
builder.append("scope ").append(scope).append(".\n");
}
var modifiedProblem = loadString(builder.toString(), problemResource.getURI());
var modifiedStatements = modifiedProblem.getStatements();
int modifiedStatementCount = modifiedStatements.size();
if (modifiedStatementCount != originalStatementCount + allScopes.size()) {
throw new IllegalArgumentException("Failed to parse scope constraints");
}
// Override scopes remove any scope constraint from the original problem with the same target type.
var overriddenScopes = new HashSet<Relation>();
for (int i = modifiedStatementCount - overrideScopes.size(); i < modifiedStatementCount; i++) {
var statement = modifiedStatements.get(i);
if (!(statement instanceof ScopeDeclaration scopeDeclaration)) {
throw new IllegalStateException("Invalid scope constraint: " + statement);
}
for (var typeScope : scopeDeclaration.getTypeScopes()) {
overriddenScopes.add(typeScope.getTargetType());
}
}
int statementIndex = 0;
var iterator = modifiedStatements.iterator();
// Scope overrides only affect type scopes from the original problem and leave type scopes added on the
// command line intact.
while (statementIndex < originalStatementCount && iterator.hasNext()) {
var statement = iterator.next();
if (statement instanceof ScopeDeclaration scopeDeclaration) {
var typeScopes = scopeDeclaration.getTypeScopes();
typeScopes.removeIf(typeScope -> overriddenScopes.contains(typeScope.getTargetType()));
// Scope declarations with no type scopes are invalid, so we have to remove them.
if (typeScopes.isEmpty()) {
iterator.remove();
}
}
statementIndex++;
}
return modifiedProblem;
}
}
|
