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 }