bundles/org.simantics.db.common/src/org/simantics/db/common/request/Queries.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.db.common.request;
  13
  14 import java.util.Collection;
  15
  16 import org.simantics.databoard.binding.Binding;
  17 import org.simantics.db.ReadGraph;
  18 import org.simantics.db.Resource;
  19 import org.simantics.db.common.uri.ResourceToPossibleURI;
  20 import org.simantics.db.common.uri.ResourceToURI;
  21 import org.simantics.db.common.utils.NameUtils;
  22 import org.simantics.db.exception.DatabaseException;
  23 import org.simantics.db.request.AsyncRead;
  24 import org.simantics.db.request.Read;
  25 import org.simantics.layer0.Layer0;
  26
  27 /**
  28  * Facade class that aggregates the most common queries.
  29  *
  30  * Example:
  31  *
  32  *   System.out.println(  session.read( Queries.adapt(r, String.class) )  );
  33  *
  34  * @author Tuukka Lehtonen
  35  * @author Toni Kalajainen
  36  */
  37 public class Queries {
  38
  39     public static AsyncRead<Resource> resource(String uri) {
  40         return new org.simantics.db.common.primitiverequest.Resource(uri);
  41     }
  42
  43     public static Read<String> name(final Resource resource) {
  44         return new ResourceRead<String>(resource) {
  45             @Override
  46             public String perform(ReadGraph graph) throws DatabaseException {
  47                 return graph.getRelatedValue(resource, Layer0.getInstance(graph).HasName);
  48             }
  49         };
  50     }
  51
  52     public static Read<String> safeName(final Resource resource) {
  53         return new ResourceRead<String>(resource) {
  54             @Override
  55             public String perform(ReadGraph graph) throws DatabaseException {
  56                 return NameUtils.getSafeName(graph, resource);
  57             }
  58         };
  59     }
  60
  61     public static Read<String> name(final String uri) {
  62         return new UnaryRead<String, String>(uri) {
  63             @Override
  64             public String perform(ReadGraph graph) throws DatabaseException {
  65                 Resource resource = graph.getResource(uri);
  66                 return graph.getRelatedValue(resource, Layer0.getInstance(graph).HasName);
  67             }
  68         };
  69     }
  70
  71     public static Read<String> uri(Resource resource) {
  72         return new ResourceToURI(resource);
  73     }
  74
  75     public static Read<String> possibleUri(Resource resource) {
  76         return new ResourceToPossibleURI(resource);
  77     }
  78
  79     public static <T> Read<T> adapt(Resource resource, Class<T> target)
  80     {
  81         return new Adapt<T>(resource, target);
  82     }
  83
  84     public static <T> Read<T> adapt(Resource resource, Class<T> target, boolean allowNull)
  85     {
  86         return new Adapt<T>(resource, target, allowNull);
  87     }
  88
  89     public static <T> Read<T> adapt(Resource resource, Class<T> target, boolean allowNull, boolean uniqueResult)
  90     {
  91         return new Adapt<T>(resource, target, allowNull, uniqueResult);
  92     }
  93
  94     public static Read<Boolean> isInstanceOf(Resource resource, Resource type)
  95     {
  96         return new IsInstanceOfQuery(resource, type);
  97     }
  98
  99     public static Read<Boolean> isInstanceOf(Resource resource, String type)
 100     {
 101         return new IsInstanceOfQuery2(resource, type);
 102     }
 103
 104     public static <T> Read<T> getRelatedValue(Resource subject, Resource relation, Binding binding)
 105     {
 106         return new ReadRelatedValue<T>(subject, relation, binding);
 107     }
 108
 109     public static <T> Read<T> getRelatedValue(Resource subject, String relation, Binding binding)
 110     {
 111         return new ReadRelatedValue2<T>(subject, relation, binding);
 112     }
 113
 114     public static <T> Read<T> getPossibleRelatedValue(Resource subject, Resource relation, Binding binding)
 115     {
 116         return new ReadPossibleRelatedValue<T>(subject, relation, binding);
 117     }
 118
 119     public static Read<Boolean> hasTag(Resource subject, Resource tag) {
 120         return new HasTag(subject, tag);
 121     }
 122
 123     public static ObjectsWithType objectsWithType(Resource subject, Resource subrelationOf, Resource instanceOf) {
 124         return new ObjectsWithType(subject, subrelationOf, instanceOf);
 125     }
 126
 127         public static Read<Resource> possibleObjectWithType(final Resource resource, final Resource predicate, final Resource type) {
 128                 return new PossibleObjectWithType(resource, predicate, type);
 129         }
 130
 131         public static Read<Resource> possibleObject(final Resource subject, final Resource predicate) {
 132                 return new Read<Resource>() {
 133                         @Override
 134                         public Resource perform(ReadGraph graph) throws DatabaseException {
 135                                 return graph.getPossibleObject(subject, predicate);
 136                         }
 137                 };
 138         }
 139
 140         public static Read<Collection<Resource>> objects(final Resource subject, final Resource predicate) {
 141                 return new Read<Collection<Resource>>() {
 142                         @Override
 143                         public Collection<Resource> perform(ReadGraph graph) throws DatabaseException {
 144                                 return graph.getObjects(subject, predicate);
 145                         }
 146                 };
 147         }
 148
 149
 150 }
 151
 152
 153 class IsInstanceOfQuery implements Read<Boolean> {
 154
 155     final protected Resource resource;
 156     final protected Resource type;
 157
 158     public IsInstanceOfQuery(Resource resource, Resource type) {
 159         this.resource = resource;
 160         this.type = type;
 161     }
 162
 163     @Override
 164     public int hashCode() {
 165         return resource.hashCode() + 13 * type.hashCode();
 166     }
 167
 168     @Override
 169     public boolean equals(Object object) {
 170         if (this == object)
 171             return true;
 172         else if (object == null)
 173             return false;
 174         else if (getClass() != object.getClass())
 175             return false;
 176         IsInstanceOfQuery other = (IsInstanceOfQuery) object;
 177         return resource.equals(other.resource) && type.equals(other.type);
 178     }
 179
 180     @Override
 181     public Boolean perform(ReadGraph graph) throws DatabaseException {
 182         return graph.isInstanceOf(resource, type);
 183     }
 184
 185 }
 186
 187 class IsInstanceOfQuery2 implements Read<Boolean> {
 188
 189     final protected Resource resource;
 190     final protected String type;
 191
 192     public IsInstanceOfQuery2(Resource resource, String type) {
 193         this.resource = resource;
 194         this.type = type;
 195     }
 196
 197     @Override
 198     public int hashCode() {
 199         return resource.hashCode() + 13 * type.hashCode();
 200     }
 201
 202     @Override
 203     public boolean equals(Object object) {
 204         if (this == object)
 205             return true;
 206         else if (object == null)
 207             return false;
 208         else if (getClass() != object.getClass())
 209             return false;
 210         IsInstanceOfQuery2 other = (IsInstanceOfQuery2) object;
 211         return resource.equals(other.resource) && type.equals(other.type);
 212     }
 213
 214     @Override
 215     public Boolean perform(ReadGraph graph) throws DatabaseException {
 216         Resource typeResource = graph.getResource(type);
 217         return graph.isInstanceOf(resource, typeResource);
 218     }
 219
 220 }
 221
 222
 223 class ReadRelatedValue<T> implements Read<T> {
 224
 225     Resource subject;
 226     Resource relation;
 227     Binding binding;
 228
 229     public ReadRelatedValue(Resource subject, Resource relation, Binding binding) {
 230         this.subject = subject;
 231         this.relation = relation;
 232         this.binding = binding;
 233     }
 234
 235     @Override
 236     public int hashCode() {
 237         return subject.hashCode() + 13 * relation.hashCode() + 7*binding.hashCode();
 238     }
 239
 240     @Override
 241     public boolean equals(Object object) {
 242         if (this == object)
 243             return true;
 244         else if (object == null)
 245             return false;
 246         else if (getClass() != object.getClass())
 247             return false;
 248         ReadRelatedValue<?> other = (ReadRelatedValue<?>) object;
 249         return subject.equals(other.subject) &&
 250         relation.equals(other.relation) &&
 251         binding.equals(other.binding);
 252     }
 253
 254     @SuppressWarnings("unchecked")
 255     @Override
 256     public T perform(ReadGraph graph) throws DatabaseException {
 257         return (T) graph.getRelatedValue(subject, relation, binding);
 258     }
 259 }
 260
 261
 262 class ReadRelatedValue2<T> implements Read<T> {
 263
 264     Resource subject;
 265     String relation;
 266     Binding binding;
 267
 268     public ReadRelatedValue2(Resource subject, String relation, Binding binding) {
 269         this.subject = subject;
 270         this.relation = relation;
 271         this.binding = binding;
 272     }
 273
 274     @Override
 275     public int hashCode() {
 276         return subject.hashCode() + 13 * relation.hashCode() + 7*binding.hashCode();
 277     }
 278
 279     @Override
 280     public boolean equals(Object object) {
 281         if (this == object)
 282             return true;
 283         else if (object == null)
 284             return false;
 285         else if (getClass() != object.getClass())
 286             return false;
 287         ReadRelatedValue2<?> other = (ReadRelatedValue2<?>) object;
 288         return subject.equals(other.subject) &&
 289         relation.equals(other.relation) &&
 290         binding.equals(other.binding);
 291     }
 292
 293     @SuppressWarnings("unchecked")
 294     @Override
 295     public T perform(ReadGraph graph) throws DatabaseException {
 296         Resource relationResource = graph.getResource(relation);
 297         return (T) graph.getRelatedValue(subject, relationResource, binding);
 298     }
 299 }
 300
 301 class ReadPossibleRelatedValue<T> implements Read<T> {
 302
 303     Resource subject;
 304     Resource relation;
 305     Binding binding;
 306
 307     public ReadPossibleRelatedValue(Resource subject, Resource relation, Binding binding) {
 308         this.subject = subject;
 309         this.relation = relation;
 310         this.binding = binding;
 311     }
 312
 313     @Override
 314     public int hashCode() {
 315         return subject.hashCode() + 13 * relation.hashCode() + 7*binding.hashCode() + 5453;
 316     }
 317
 318     @Override
 319     public boolean equals(Object object) {
 320         if (this == object)
 321             return true;
 322         else if (object == null)
 323             return false;
 324         else if (getClass() != object.getClass())
 325             return false;
 326         ReadPossibleRelatedValue<?> other = (ReadPossibleRelatedValue<?>) object;
 327         return subject.equals(other.subject) &&
 328         relation.equals(other.relation) &&
 329         binding.equals(other.binding);
 330     }
 331
 332     @SuppressWarnings("unchecked")
 333     @Override
 334     public T perform(ReadGraph graph) throws DatabaseException {
 335         return (T) graph.getPossibleRelatedValue(subject, relation, binding);
 336     }
 337 }
 338
 339 class HasTag extends ResourceRead2<Boolean> {
 340     public HasTag(Resource subject, Resource tag) {
 341         super(subject, tag);
 342     }
 343
 344     @Override
 345     public Boolean perform(ReadGraph graph) throws DatabaseException {
 346         return Boolean.valueOf(graph.hasStatement(resource, resource2, resource));
 347     }
 348 }