bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/variable/ValueProxyVariable.java

   1 package org.simantics.db.layer0.variable;
   2
   3 import java.util.Collection;
   4 import java.util.Collections;
   5 import java.util.Set;
   6
   7 import org.simantics.databoard.binding.Binding;
   8 import org.simantics.databoard.binding.mutable.Variant;
   9 import org.simantics.databoard.type.Datatype;
  10 import org.simantics.db.ReadGraph;
  11 import org.simantics.db.Resource;
  12 import org.simantics.db.WriteGraph;
  13 import org.simantics.db.common.utils.NameUtils;
  14 import org.simantics.db.exception.DatabaseException;
  15 import org.simantics.db.layer0.exception.InvalidVariableException;
  16 import org.simantics.db.layer0.exception.MissingVariableException;
  17 import org.simantics.db.layer0.exception.MissingVariableValueException;
  18 import org.simantics.db.layer0.exception.NonWritableVariableException;
  19 import org.simantics.db.layer0.request.PropertyInfo;
  20 import org.simantics.db.layer0.variable.RVI.RVIPart;
  21 import org.simantics.db.layer0.variable.Variables.Role;
  22
  23 /**
  24  * An abstract base proxy implementation for value container variables that are
  25  * leaves of the variable tree. This means by default the variable has no
  26  * support for children or properties, only for returning a single value that it
  27  * wraps.
  28  *
  29  * @author Tuukka Lehtonen
  30  */
  31 public abstract class ValueProxyVariable implements Variable {
  32
  33         protected final Variable proxy;
  34         protected final Variable parent;
  35
  36         public ValueProxyVariable(Variable proxy, Variable parent) {
  37                 if (proxy == null)
  38                         throw new NullPointerException("null proxy");
  39                 if (parent == null)
  40                         throw new NullPointerException("null parent");
  41                 this.parent = parent;
  42                 this.proxy = proxy;
  43         }
  44
  45         @Override
  46         public <T> T getPropertyValue(ReadGraph graph, String name) throws DatabaseException {
  47                 throw new MissingVariableValueException("Could not resolve property " + name);
  48         }
  49
  50         @Override
  51         public <T> T getPropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
  52                 throw new MissingVariableValueException("Could not resolve property " + NameUtils.getSafeName(graph, property, true));
  53         }
  54
  55         @Override
  56         public <T> T getPossiblePropertyValue(ReadGraph graph, String name) throws DatabaseException {
  57                 throw new MissingVariableValueException("Could not resolve property " + name);
  58         }
  59
  60         @Override
  61         public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property) throws DatabaseException {
  62                 throw new MissingVariableValueException("Could not resolve property " + NameUtils.getSafeName(graph, property, true));
  63         }
  64
  65         @Override
  66         public <T> T getPropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
  67                 throw new MissingVariableValueException("Could not resolve property " + name);
  68         }
  69
  70         @Override
  71         public <T> T getPropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
  72                 throw new MissingVariableValueException("Could not resolve property " + NameUtils.getSafeName(graph, property, true));
  73         }
  74
  75         @Override
  76         public <T> T getPossiblePropertyValue(ReadGraph graph, String name, Binding binding) throws DatabaseException {
  77                 throw new MissingVariableValueException("Could not resolve property " + name);
  78         }
  79
  80         @Override
  81         public <T> T getPossiblePropertyValue(ReadGraph graph, Resource property, Binding binding) throws DatabaseException {
  82                 return proxy.getPossiblePropertyValue(graph, property, binding);
  83         }
  84
  85         @Override
  86         public PropertyInfo getPropertyInfo(ReadGraph graph) throws DatabaseException {
  87                 return proxy.getPropertyInfo(graph);
  88         }
  89
  90         @Override
  91         public Resource getIndexRoot(ReadGraph graph) throws DatabaseException {
  92                 return proxy.getIndexRoot(graph);
  93         }
  94
  95         @Override
  96         public abstract <T> T getValue(ReadGraph graph) throws DatabaseException;
  97
  98         @Override
  99         public abstract <T> T getPossibleValue(ReadGraph graph) throws DatabaseException;
 100
 101         @Override
 102         public abstract <T> T getValue(ReadGraph graph, Binding binding) throws DatabaseException;
 103
 104         @Override
 105         public abstract <T> T getPossibleValue(ReadGraph graph, Binding binding) throws DatabaseException;
 106
 107         @Override
 108         public void setValue(WriteGraph graph, Object value, Binding binding) throws DatabaseException {
 109                 throw new NonWritableVariableException("Not supported");
 110         }
 111
 112         @Override
 113         public void setValue(WriteGraph graph, Object value) throws DatabaseException {
 114                 throw new NonWritableVariableException("Not supported");
 115         }
 116
 117         @Override
 118         public void setPropertyValue(WriteGraph graph, String name, Object value, Binding binding) throws DatabaseException {
 119                 throw new NonWritableVariableException("Not supported");
 120         }
 121
 122         @Override
 123         public void setPropertyValue(WriteGraph graph, Resource property, Object value, Binding binding) throws DatabaseException {
 124                 throw new NonWritableVariableException("Not supported");
 125         }
 126
 127         @Override
 128         public void setPropertyValue(WriteGraph graph, String name, Object value) throws DatabaseException {
 129                 throw new NonWritableVariableException("Not supported");
 130         }
 131
 132         @Override
 133         public void setPropertyValue(WriteGraph graph, Resource property, Object value) throws DatabaseException {
 134                 throw new NonWritableVariableException("Not supported");
 135         }
 136
 137         @Override
 138         public Variable getChild(ReadGraph graph, String name) throws DatabaseException {
 139                 throw new MissingVariableException("Could not resolve child " + name, getPossibleRepresents(graph));
 140         }
 141
 142         @Override
 143         public Variable getPossibleChild(ReadGraph graph, String name) throws DatabaseException {
 144                 return null;
 145         }
 146
 147         @Override
 148         public Variable getProperty(ReadGraph graph, String name) throws DatabaseException {
 149                 throw new MissingVariableException("Could not resolve property " + name, getPossibleRepresents(graph));
 150         }
 151
 152         @Override
 153         public Variable getProperty(ReadGraph graph, Resource property) throws DatabaseException {
 154                 throw new MissingVariableException("Could not resolve property " + NameUtils.getSafeName(graph, property, true), getPossibleRepresents(graph));
 155         }
 156
 157         @Override
 158         public Variable getPossibleProperty(ReadGraph graph, String name) throws DatabaseException {
 159                 return null;
 160         }
 161
 162         @Override
 163         public Variable getPossibleProperty(ReadGraph graph, Resource property) throws DatabaseException {
 164                 return null;
 165         }
 166
 167         @Override
 168         public Collection<Variable> browseChildren(ReadGraph graph) throws DatabaseException {
 169                 return getChildren(graph);
 170         }
 171
 172         @Override
 173         public Collection<Variable> getChildren(ReadGraph graph) throws DatabaseException {
 174                 return Collections.emptyList();
 175         }
 176
 177         @Override
 178         public Collection<Variable> browseProperties(ReadGraph graph) throws DatabaseException {
 179                 return getProperties(graph);
 180         }
 181
 182         @Override
 183         public Collection<Variable> getProperties(ReadGraph graph) throws DatabaseException {
 184                 return Collections.emptyList();
 185         }
 186
 187         @Override
 188         public Collection<Variable> getProperties(ReadGraph graph, String classification) throws DatabaseException {
 189                 return Collections.emptyList();
 190         }
 191
 192         @Override
 193         public Collection<Variable> getProperties(ReadGraph graph, Resource classification) throws DatabaseException {
 194                 return Collections.emptyList();
 195         }
 196
 197         @Override
 198         public Variable browse(ReadGraph graph, String suffix) throws DatabaseException {
 199                 if (suffix.isEmpty())
 200                         return this;
 201                 throw new MissingVariableException("Could not browse with suffix '" + suffix + "'", getPossibleRepresents(graph));
 202         }
 203
 204         @Override
 205         public Variable browsePossible(ReadGraph graph, String suffix) throws DatabaseException {
 206                 if (suffix.isEmpty())
 207                         return this;
 208                 return null;
 209         }
 210
 211         @Override
 212         public Variable browse(ReadGraph graph, Resource config) throws DatabaseException {
 213                 throw new MissingVariableException("Could not browse '" + NameUtils.getSafeName(graph, config, true) + "'", getPossibleRepresents(graph));
 214         }
 215
 216         @Override
 217         public Variable browsePossible(ReadGraph graph, Resource config) throws DatabaseException {
 218                 return null;
 219         }
 220
 221         @Override
 222         public <T> T getInterface(ReadGraph graph, Class<T> clazz) throws DatabaseException {
 223                 return null;
 224         }
 225
 226         @Override
 227         public <T> T adapt(ReadGraph graph, Class<T> clazz) throws DatabaseException {
 228                 return null;
 229         }
 230
 231         @Override
 232         public <T> T adaptPossible(ReadGraph graph, Class<T> clazz) throws DatabaseException {
 233                 return null;
 234         }
 235
 236         @Override
 237         public abstract String getURI(ReadGraph graph) throws DatabaseException;
 238
 239         @Override
 240         public abstract int hashCode();
 241
 242         @Override
 243         public abstract boolean equals(Object obj);
 244
 245         @Override
 246         public Variable resolve(ReadGraph graph, RVIPart part) throws DatabaseException {
 247                 throw new InvalidVariableException("not supported");
 248         }
 249
 250         @Override
 251         public Variable resolvePossible(ReadGraph graph, RVIPart part) throws DatabaseException {
 252                 return null;
 253         }
 254
 255         @Override
 256         public abstract String getName(ReadGraph graph) throws DatabaseException;
 257
 258         @Override
 259         public String getLabel(ReadGraph graph) throws DatabaseException {
 260                 throw new InvalidVariableException("not supported");
 261         }
 262
 263         @Override
 264         public abstract Datatype getDatatype(ReadGraph graph) throws DatabaseException;
 265
 266         @Override
 267         public Datatype getPossibleDatatype(ReadGraph graph) throws DatabaseException {
 268                 try {
 269                         return getDatatype(graph);
 270                 } catch (DatabaseException e) {
 271                         return null;
 272                 }
 273         }
 274
 275         @Override
 276         public Variable getPredicate(ReadGraph graph) throws DatabaseException {
 277                 throw new InvalidVariableException("not supported");
 278         }
 279
 280         @Override
 281         public Variable getPossiblePredicate(ReadGraph graph) throws DatabaseException {
 282                 throw new InvalidVariableException("not supported");
 283         }
 284
 285         @Override
 286         public Resource getPredicateResource(ReadGraph graph) throws DatabaseException {
 287                 throw new InvalidVariableException("not supported");
 288         }
 289
 290         @Override
 291         public Resource getPossiblePredicateResource(ReadGraph graph) throws DatabaseException {
 292                 try {
 293                         return getPredicateResource(graph);
 294                 } catch (DatabaseException e) {
 295                         return null;
 296                 }
 297         }
 298
 299         @Override
 300         public Variable getParent(ReadGraph graph) throws DatabaseException {
 301                 return parent;
 302         }
 303
 304         @Override
 305         public Resource getRepresents(ReadGraph graph) throws DatabaseException {
 306                 throw new InvalidVariableException("no resource representation");
 307         }
 308
 309         @Override
 310         public Resource getPossibleRepresents(ReadGraph graph) throws DatabaseException {
 311                 return null;
 312         }
 313
 314         @Override
 315         public Resource getType(ReadGraph graph) throws DatabaseException {
 316                 throw new InvalidVariableException("not supported");
 317         }
 318
 319         @Override
 320         public Resource getPossibleType(ReadGraph graph) throws DatabaseException {
 321                 return null;
 322         }
 323
 324         @Override
 325         public Resource getType(ReadGraph graph, Resource baseType) throws DatabaseException {
 326                 throw new InvalidVariableException("not supported");
 327         }
 328
 329         @Override
 330         public Resource getPossibleType(ReadGraph graph, Resource baseType) throws DatabaseException {
 331                 return null;
 332         }
 333
 334         @Override
 335         public abstract RVI getRVI(ReadGraph graph) throws DatabaseException;
 336
 337         @Override
 338         public RVI getPossibleRVI(ReadGraph graph) throws DatabaseException {
 339                 try {
 340                         return getRVI(graph);
 341                 } catch (DatabaseException e) {
 342                         return null;
 343                 }
 344         }
 345
 346         @Override
 347         public Role getRole(ReadGraph graph) throws DatabaseException {
 348                 return Role.PROPERTY;
 349         }
 350
 351         @Override
 352         public Role getPossibleRole(ReadGraph graph) throws DatabaseException {
 353                 return Role.PROPERTY;
 354         }
 355
 356         @Override
 357         public Set<String> getClassifications(ReadGraph graph) throws DatabaseException {
 358                 return Collections.emptySet();
 359         }
 360
 361         public abstract Variant getVariantValue(ReadGraph graph) throws DatabaseException;
 362
 363 }