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
|
/*******************************************************************************
* Copyright (c) 2010-2015, Abel Hegedus, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-v20.html.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package tools.refinery.interpreter.matchers.context.surrogate;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import tools.refinery.interpreter.matchers.psystem.queries.PQuery;
import tools.refinery.interpreter.matchers.context.IInputKey;
import tools.refinery.interpreter.matchers.util.IProvider;
import tools.refinery.interpreter.matchers.util.Preconditions;
import tools.refinery.interpreter.matchers.util.SingletonInstanceProvider;
/**
* @author Abel Hegedus
*
*/
public class SurrogateQueryRegistry {
private Map<IInputKey, IProvider<PQuery>> registeredSurrogateQueryMap = new HashMap<>();
private Map<IInputKey, IProvider<PQuery>> dynamicSurrogateQueryMap = new HashMap<>();
/**
* Hidden constructor
*/
private SurrogateQueryRegistry() {
}
private static final SurrogateQueryRegistry INSTANCE = new SurrogateQueryRegistry();
public static SurrogateQueryRegistry instance() {
return INSTANCE;
}
/**
*
* @param feature
* @param surrogateQuery
* @return the previous surrogate query associated with feature, or null if there was no such query FQN registered
* @throws IllegalArgumentException if feature or surrogateQuery is null
*/
public IProvider<PQuery> registerSurrogateQueryForFeature(IInputKey feature, PQuery surrogateQuery) {
Preconditions.checkArgument(surrogateQuery != null, "Surrogate query must not be null!");
return registerSurrogateQueryForFeature(feature, new SingletonInstanceProvider<PQuery>(surrogateQuery));
}
/**
*
* @param feature
* @param surrogateQuery
* @return the previous surrogate query associated with feature, or null
* if there was no such query registered
* @throws IllegalArgumentException
* if feature or surrogateQuery is null
*/
public IProvider<PQuery> registerSurrogateQueryForFeature(IInputKey feature, IProvider<PQuery> surrogateQueryProvider) {
Preconditions.checkArgument(feature != null, "Feature must not be null!");
Preconditions.checkArgument(surrogateQueryProvider != null, "Surrogate query must not be null!");
return registeredSurrogateQueryMap.put(feature, surrogateQueryProvider);
}
public IProvider<PQuery> addDynamicSurrogateQueryForFeature(IInputKey feature, PQuery surrogateQuery) {
Preconditions.checkArgument(surrogateQuery != null, "Surrogate query FQN must not be null!");
return addDynamicSurrogateQueryForFeature(feature, new SingletonInstanceProvider<PQuery>(surrogateQuery));
}
public IProvider<PQuery> addDynamicSurrogateQueryForFeature(IInputKey feature, IProvider<PQuery> surrogateQuery) {
Preconditions.checkArgument(feature != null, "Feature must not be null!");
Preconditions.checkArgument(surrogateQuery != null, "Surrogate query FQN must not be null!");
return dynamicSurrogateQueryMap.put(feature, surrogateQuery);
}
public IProvider<PQuery> removeDynamicSurrogateQueryForFeature(IInputKey feature) {
Preconditions.checkArgument(feature != null, "Feature must not be null!");
return dynamicSurrogateQueryMap.remove(feature);
}
/**
*
* @param feature that may have surrogate query defined, null not allowed
* @return true if the feature has a surrogate query defined
* @throws IllegalArgumentException if feature is null
*/
public boolean hasSurrogateQueryFQN(IInputKey feature) {
Preconditions.checkArgument(feature != null, "Feature must not be null!");
boolean surrogateExists = dynamicSurrogateQueryMap.containsKey(feature);
if(!surrogateExists){
surrogateExists = registeredSurrogateQueryMap.containsKey(feature);
}
return surrogateExists;
}
/**
*
* @param feature for which the surrogate query FQN should be returned
* @return the surrogate query FQN defined for the feature
* @throws IllegalArgumentException if feature is null
* @throws NoSuchElementException if the feature has no surrogate query defined, use {@link #hasSurrogateQueryFQN} to check
*/
public PQuery getSurrogateQuery(IInputKey feature) {
Preconditions.checkArgument(feature != null, "Feature must not be null!");
IProvider<PQuery> surrogate = dynamicSurrogateQueryMap.get(feature);
if(surrogate == null) {
surrogate = registeredSurrogateQueryMap.get(feature);
}
if(surrogate != null) {
return surrogate.get();
} else {
throw new NoSuchElementException(String.format("Feature %s has no surrogate query defined! Use #hasSurrogateQueryFQN to check existence.", feature));
}
}
/**
* @return an unmodifiable set of features with registered surrogate queries
*/
public Set<IInputKey> getRegisteredSurrogateQueries() {
return Collections.unmodifiableSet(getRegisteredSurrogateQueriesInternal());
}
private Set<IInputKey> getRegisteredSurrogateQueriesInternal() {
return registeredSurrogateQueryMap.keySet();
}
/**
* @return an unmodifiable set of features with dynamically added surrogate queries
*/
public Set<IInputKey> getDynamicSurrogateQueries() {
return Collections.unmodifiableSet(getDynamicSurrogateQueriesInternal());
}
private Set<IInputKey> getDynamicSurrogateQueriesInternal() {
return dynamicSurrogateQueryMap.keySet();
}
/**
* @return an unmodifiable set that contains all features with surrogate queries.
*/
public Set<IInputKey> getAllSurrogateQueries() {
Set<IInputKey> results = new HashSet<>(getRegisteredSurrogateQueriesInternal());
results.addAll(getDynamicSurrogateQueriesInternal());
return results;
}
}
|
