]> gerrit.simantics Code Review - simantics/platform.git/blob - bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/variable/ProxyVariable.java
New implementation NearestOwnerFinder of CommonDBUtils.getNearestOwner
[simantics/platform.git] / bundles / org.simantics.db.layer0 / src / org / simantics / db / layer0 / variable / ProxyVariable.java
1 package org.simantics.db.layer0.variable;
2
3 import java.util.Collection;
4 import java.util.Set;
5
6 import org.simantics.databoard.binding.Binding;
7 import org.simantics.databoard.binding.mutable.Variant;
8 import org.simantics.databoard.type.Datatype;
9 import org.simantics.db.ReadGraph;
10 import org.simantics.db.Resource;
11 import org.simantics.db.WriteGraph;
12 import org.simantics.db.exception.DatabaseException;
13 import org.simantics.db.layer0.variable.RVI.RVIPart;
14
15 /**
16  * @deprecated this implementation is pretty much useless, it is too
17  *             straightforward and requires extenders to override pretty much
18  *             everything in it to work correctly. Do not use.
19  * @see ValueProxyVariable
20  */
21 @Deprecated
22 public abstract class ProxyVariable implements Variable {
23
24     protected final Variable proxy;
25     protected final Variable parent;
26
27     public ProxyVariable(Variable proxy, Variable parent) {
28         if (proxy == null)
29             throw new NullPointerException("null proxy");
30         if (parent == null)
31             throw new NullPointerException("null parent");
32         this.parent = parent;
33         this.proxy = proxy;
34     }
35
36     @Override
37     public <T> T getPropertyValue(ReadGraph graph, String name) throws DatabaseException {
38         return proxy.getPropertyValue(graph, name);
39     }
40
41     @Override
42     public <T> T getPropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
43         return proxy.getPropertyValue(graph, property);
44     }
45
46     @Override
47     public <T> T getPossiblePropertyValue(ReadGraph graph, String name) throws DatabaseException {
48         return proxy.getPossiblePropertyValue(graph, name);
49     }
50
51     @Override
52     public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
53         return proxy.getPossiblePropertyValue(graph, property);
54     }
55
56     @Override
57     public <T> T getPropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
58         return proxy.getPropertyValue(graph, name, binding);
59     }
60
61     @Override
62     public <T> T getPropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
63         return proxy.getPropertyValue(graph, property, binding);
64     }
65
66     @Override
67     public <T> T getPossiblePropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
68         return proxy.getPossiblePropertyValue(graph, name, binding);
69     }
70
71     @Override
72     public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
73         return proxy.getPossiblePropertyValue(graph, property, binding);
74     }
75
76     @Override
77     public <T> T getValue(ReadGraph graph) throws DatabaseException {
78         return proxy.getValue(graph);
79     }
80
81     @Override
82     public <T> T getPossibleValue(ReadGraph graph) throws DatabaseException {
83         return proxy.getPossibleValue(graph);
84     }
85
86     @Override
87     public <T> T getValue(ReadGraph graph, Binding binding) throws DatabaseException {
88         return proxy.getValue(graph, binding);
89     }
90
91     @Override
92     public <T> T getPossibleValue(ReadGraph graph, Binding binding) throws DatabaseException {
93         return proxy.getPossibleValue(graph, binding);
94     }
95
96     @Override
97     public void setValue(WriteGraph graph, Object value, Binding binding) throws DatabaseException {
98         proxy.setValue(graph, value, binding);
99     }
100
101     @Override
102     public void setValue(WriteGraph graph, Object value) throws DatabaseException {
103         proxy.setValue(graph, value);
104     }
105
106     @Override
107     public void setPropertyValue(WriteGraph graph, String name, Object value, Binding binding) throws DatabaseException {
108         proxy.setPropertyValue(graph, name, value, binding);
109     }
110
111     @Override
112     public void setPropertyValue(WriteGraph graph, Resource property, Object value, Binding binding) throws DatabaseException {
113         proxy.setPropertyValue(graph, property, value, binding);
114     }
115
116     @Override
117     public void setPropertyValue(WriteGraph graph, String name, Object value) throws DatabaseException {
118         proxy.setPropertyValue(graph, name, value);
119     }
120
121     @Override
122     public void setPropertyValue(WriteGraph graph, Resource property, Object value) throws DatabaseException {
123         proxy.setPropertyValue(graph, property, value);
124     }
125
126     @Override
127     public Variable getChild(ReadGraph graph, String name) throws DatabaseException {
128         return proxy.getChild(graph, name);
129     }
130
131     @Override
132     public Variable getPossibleChild(ReadGraph graph, String name) throws DatabaseException {
133         return proxy.getPossibleChild(graph, name);
134     }
135
136     @Override
137     public Variable getProperty(ReadGraph graph, String name) throws DatabaseException {
138         return proxy.getProperty(graph, name);
139     }
140
141     @Override
142     public Variable getProperty(ReadGraph graph, Resource property) throws DatabaseException {
143         return proxy.getProperty(graph, property);
144     }
145
146     @Override
147     public Variable getPossibleProperty(ReadGraph graph, String name) throws DatabaseException {
148         return proxy.getPossibleProperty(graph, name);
149     }
150
151     @Override
152     public Variable getPossibleProperty(ReadGraph graph, Resource property) throws DatabaseException {
153         return proxy.getPossibleProperty(graph, property);
154     }
155
156     @Override
157     public Collection<Variable> browseChildren(ReadGraph graph) throws DatabaseException {
158         return proxy.browseChildren(graph);
159     }
160
161     @Override
162     public Collection<Variable> getChildren(ReadGraph graph) throws DatabaseException {
163         return proxy.getChildren(graph);
164     }
165
166     @Override
167     public Collection<Variable> browseProperties(ReadGraph graph) throws DatabaseException {
168         return proxy.browseProperties(graph);
169     }
170
171     @Override
172     public Collection<Variable> getProperties(ReadGraph graph) throws DatabaseException {
173         return proxy.getProperties(graph);
174     }
175
176     @Override
177     public Collection<Variable> getProperties(ReadGraph graph, String classification) throws DatabaseException {
178         return proxy.getProperties(graph, classification);
179     }
180
181     @Override
182     public Collection<Variable> getProperties(ReadGraph graph, Resource classification) throws DatabaseException {
183         return proxy.getProperties(graph, classification);
184     }
185
186     @Override
187     public Variable browse(ReadGraph graph, String suffix) throws DatabaseException {
188         if (suffix.isEmpty())
189             return this;
190         return proxy.browse(graph, suffix);
191     }
192
193     @Override
194     public Variable browsePossible(ReadGraph graph, String suffix) throws DatabaseException {
195         if (suffix.isEmpty())
196             return this;
197         return proxy.browsePossible(graph, suffix);
198     }
199
200     @Override
201     public Variable browse(ReadGraph graph, Resource config) throws DatabaseException {
202         return proxy.browse(graph, config);
203     }
204
205     @Override
206     public Variable browsePossible(ReadGraph graph, Resource config) throws DatabaseException {
207         return proxy.browsePossible(graph, config);
208     }
209
210     @Override
211     public <T> T getInterface(ReadGraph graph, Class<T> clazz) throws DatabaseException {
212         return proxy.getInterface(graph, clazz);
213     }
214
215     @Override
216     public <T> T adapt(ReadGraph graph, Class<T> clazz) throws DatabaseException {
217         return proxy.adapt(graph, clazz);
218     }
219
220     @Override
221     public <T> T adaptPossible(ReadGraph graph, Class<T> clazz) throws DatabaseException {
222         return proxy.adaptPossible(graph, clazz);
223     }
224
225     @Override
226     public String getURI(ReadGraph graph) throws DatabaseException {
227         return proxy.getURI(graph);
228     }
229
230     @Override
231     public abstract int hashCode();
232
233     @Override
234     public abstract boolean equals(Object obj);
235
236     @Override
237     public Variable resolve(ReadGraph graph, RVIPart part) throws DatabaseException {
238         return proxy.resolve(graph, part);
239     }
240
241     @Override
242     public Variable resolvePossible(ReadGraph graph, RVIPart part) throws DatabaseException {
243         return proxy.resolvePossible(graph, part);
244     }
245
246     @Override
247     public String getName(ReadGraph graph) throws DatabaseException {
248         return proxy.getName(graph);
249     }
250
251     @Override
252     public String getLabel(ReadGraph graph) throws DatabaseException {
253         return proxy.getLabel(graph);
254     }
255
256     @Override
257     public Datatype getDatatype(ReadGraph graph) throws DatabaseException {
258         return proxy.getDatatype(graph);
259     }
260
261     @Override
262     public Datatype getPossibleDatatype(ReadGraph graph) throws DatabaseException {
263         return proxy.getPossibleDatatype(graph);
264     }
265
266     @Override
267     public Variable getPredicate(ReadGraph graph) throws DatabaseException {
268         return proxy.getPredicate(graph);
269     }
270
271     @Override
272     public Variable getPossiblePredicate(ReadGraph graph) throws DatabaseException {
273         return proxy.getPossiblePredicate(graph);
274     }
275
276     @Override
277     public Resource getPredicateResource(ReadGraph graph) throws DatabaseException {
278         return proxy.getPredicateResource(graph);
279     }
280
281     @Override
282     public Resource getPossiblePredicateResource(ReadGraph graph) throws DatabaseException {
283         return proxy.getPossiblePredicateResource(graph);
284     }
285     
286     @Override
287     public Variable getParent(ReadGraph graph) throws DatabaseException {
288         return parent;
289     }
290
291     @Override
292     public Resource getRepresents(ReadGraph graph) throws DatabaseException {
293         return proxy.getRepresents(graph);
294     }
295
296     @Override
297     public Resource getPossibleRepresents(ReadGraph graph) throws DatabaseException {
298         return proxy.getPossibleRepresents(graph);
299     }
300
301     @Override
302     public Resource getType(ReadGraph graph) throws DatabaseException {
303         return proxy.getType(graph);
304     }
305
306     @Override
307     public Resource getPossibleType(ReadGraph graph) throws DatabaseException {
308         return proxy.getPossibleType(graph);
309     }
310
311     @Override
312     public RVI getRVI(ReadGraph graph) throws DatabaseException {
313         return proxy.getRVI(graph);
314     }
315
316     @Override
317     public RVI getPossibleRVI(ReadGraph graph) throws DatabaseException {
318         return proxy.getPossibleRVI(graph);
319     }
320
321     @Override
322     public Set<String> getClassifications(ReadGraph graph) throws DatabaseException {
323         return proxy.getClassifications(graph);
324     }
325
326     public Variant getVariantValue(ReadGraph graph) throws DatabaseException {
327         return proxy.getVariantValue(graph);
328     }
329
330         @Override
331         public Resource getType(ReadGraph graph, Resource baseType) throws DatabaseException {
332                 return proxy.getType(graph, baseType);
333         }
334
335         @Override
336         public Resource getPossibleType(ReadGraph graph, Resource baseType) throws DatabaseException {
337                 return proxy.getPossibleType(graph, baseType);
338         }
339 }