bundles/org.simantics.db.impl/src/org/simantics/db/impl/graph/ReadGraphImpl.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.impl.graph;
  13
  14 import java.io.BufferedOutputStream;
  15 import java.io.File;
  16 import java.io.FileOutputStream;
  17 import java.io.IOException;
  18 import java.io.PrintStream;
  19 import java.lang.reflect.Array;
  20 import java.lang.reflect.InvocationTargetException;
  21 import java.nio.BufferUnderflowException;
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.IdentityHashMap;
  26 import java.util.Iterator;
  27 import java.util.List;
  28 import java.util.ListIterator;
  29 import java.util.Map;
  30 import java.util.Set;
  31 import java.util.function.Consumer;
  32
  33 import org.eclipse.core.runtime.Platform;
  34 import org.simantics.databoard.Accessors;
  35 import org.simantics.databoard.Bindings;
  36 import org.simantics.databoard.accessor.Accessor;
  37 import org.simantics.databoard.accessor.error.AccessorConstructionException;
  38 import org.simantics.databoard.adapter.AdaptException;
  39 import org.simantics.databoard.binding.Binding;
  40 import org.simantics.databoard.binding.error.RuntimeBindingConstructionException;
  41 import org.simantics.databoard.binding.impl.ObjectVariantBinding;
  42 import org.simantics.databoard.binding.mutable.Variant;
  43 import org.simantics.databoard.serialization.Serializer;
  44 import org.simantics.databoard.type.Datatype;
  45 import org.simantics.databoard.util.binary.BinaryFile;
  46 import org.simantics.databoard.util.binary.RandomAccessBinary;
  47 import org.simantics.db.AsyncReadGraph;
  48 import org.simantics.db.DevelopmentKeys;
  49 import org.simantics.db.ExternalValue;
  50 import org.simantics.db.ExternalValueSupport;
  51 import org.simantics.db.ReadGraph;
  52 import org.simantics.db.RelationContext;
  53 import org.simantics.db.Resource;
  54 import org.simantics.db.Session;
  55 import org.simantics.db.Statement;
  56 import org.simantics.db.adaption.AdaptionService;
  57 import org.simantics.db.common.primitiverequest.Adapter;
  58 import org.simantics.db.common.primitiverequest.Builtin;
  59 import org.simantics.db.common.primitiverequest.DatatypeBinding;
  60 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
  61 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
  62 import org.simantics.db.common.primitiverequest.HasStatement;
  63 import org.simantics.db.common.primitiverequest.HasStatementSubject;
  64 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
  65 import org.simantics.db.common.primitiverequest.HasValue;
  66 import org.simantics.db.common.primitiverequest.Inverse;
  67 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
  68 import org.simantics.db.common.primitiverequest.IsInstanceOf;
  69 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
  70 import org.simantics.db.common.primitiverequest.OrderedSet;
  71 import org.simantics.db.common.primitiverequest.PossibleAdapter;
  72 import org.simantics.db.common.primitiverequest.PossibleInverse;
  73 import org.simantics.db.common.primitiverequest.PossibleObject;
  74 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
  75 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
  76 import org.simantics.db.common.primitiverequest.PossibleStatement;
  77 import org.simantics.db.common.primitiverequest.PossibleType;
  78 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
  79 import org.simantics.db.common.primitiverequest.PossibleValue;
  80 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
  81 import org.simantics.db.common.primitiverequest.RelatedValue;
  82 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
  83 import org.simantics.db.common.primitiverequest.SingleObject;
  84 import org.simantics.db.common.primitiverequest.SingleStatement;
  85 import org.simantics.db.common.primitiverequest.SingleType;
  86 import org.simantics.db.common.primitiverequest.SingleTypeAny;
  87 import org.simantics.db.common.primitiverequest.Types;
  88 import org.simantics.db.common.primitiverequest.UniqueAdapter;
  89 import org.simantics.db.common.primitiverequest.Value;
  90 import org.simantics.db.common.primitiverequest.ValueImplied;
  91 import org.simantics.db.common.primitiverequest.VariantValueImplied;
  92 import org.simantics.db.common.procedure.BlockingAsyncProcedure;
  93 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
  94 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
  95 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  96 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
  97 import org.simantics.db.common.procedure.single.SyncReadProcedure;
  98 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
  99 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
 100 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
 101 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
 102 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
 103 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
 104 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
 105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
 106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
 107 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
 108 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
 109 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
 110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
 111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
 112 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
 113 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
 114 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
 115 import org.simantics.db.common.request.AdaptValue;
 116 import org.simantics.db.common.request.ResourceRead;
 117 import org.simantics.db.common.utils.Functions;
 118 import org.simantics.db.common.utils.Logger;
 119 import org.simantics.db.common.utils.NameUtils;
 120 import org.simantics.db.common.validation.L0Validations;
 121 import org.simantics.db.exception.AdaptionException;
 122 import org.simantics.db.exception.ArgumentException;
 123 import org.simantics.db.exception.AssumptionException;
 124 import org.simantics.db.exception.BindingException;
 125 import org.simantics.db.exception.DatabaseException;
 126 import org.simantics.db.exception.DoesNotContainValueException;
 127 import org.simantics.db.exception.EmptyResourceException;
 128 import org.simantics.db.exception.InternalException;
 129 import org.simantics.db.exception.InvalidLiteralException;
 130 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
 131 import org.simantics.db.exception.NoInverseException;
 132 import org.simantics.db.exception.NoSingleResultException;
 133 import org.simantics.db.exception.ResourceNotFoundException;
 134 import org.simantics.db.exception.ServiceException;
 135 import org.simantics.db.exception.ValidationException;
 136 import org.simantics.db.impl.RelationContextImpl;
 137 import org.simantics.db.impl.ResourceImpl;
 138 import org.simantics.db.impl.internal.RandomAccessValueSupport;
 139 import org.simantics.db.impl.internal.ResourceData;
 140 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
 141 import org.simantics.db.impl.procedure.InternalProcedure;
 142 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
 143 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
 144 import org.simantics.db.impl.query.CacheEntry;
 145 import org.simantics.db.impl.query.QueryCache;
 146 import org.simantics.db.impl.query.QueryCacheBase;
 147 import org.simantics.db.impl.query.QueryProcessor;
 148 import org.simantics.db.impl.query.QuerySupport;
 149 import org.simantics.db.impl.query.TripleIntProcedure;
 150 import org.simantics.db.impl.query.QueryProcessor.SessionTask;
 151 import org.simantics.db.impl.support.ResourceSupport;
 152 import org.simantics.db.procedure.AsyncListener;
 153 import org.simantics.db.procedure.AsyncMultiListener;
 154 import org.simantics.db.procedure.AsyncMultiProcedure;
 155 import org.simantics.db.procedure.AsyncProcedure;
 156 import org.simantics.db.procedure.AsyncSetListener;
 157 import org.simantics.db.procedure.Listener;
 158 import org.simantics.db.procedure.ListenerBase;
 159 import org.simantics.db.procedure.MultiListener;
 160 import org.simantics.db.procedure.MultiProcedure;
 161 import org.simantics.db.procedure.Procedure;
 162 import org.simantics.db.procedure.SetListener;
 163 import org.simantics.db.procedure.StatementProcedure;
 164 import org.simantics.db.procedure.SyncListener;
 165 import org.simantics.db.procedure.SyncMultiListener;
 166 import org.simantics.db.procedure.SyncMultiProcedure;
 167 import org.simantics.db.procedure.SyncProcedure;
 168 import org.simantics.db.procedure.SyncSetListener;
 169 import org.simantics.db.request.AsyncMultiRead;
 170 import org.simantics.db.request.AsyncRead;
 171 import org.simantics.db.request.DelayedWrite;
 172 import org.simantics.db.request.DelayedWriteResult;
 173 import org.simantics.db.request.ExternalRead;
 174 import org.simantics.db.request.MultiRead;
 175 import org.simantics.db.request.Read;
 176 import org.simantics.db.request.ReadInterface;
 177 import org.simantics.db.request.RequestFlags;
 178 import org.simantics.db.request.Write;
 179 import org.simantics.db.request.WriteInterface;
 180 import org.simantics.db.request.WriteOnly;
 181 import org.simantics.db.request.WriteOnlyResult;
 182 import org.simantics.db.request.WriteResult;
 183 import org.simantics.layer0.Layer0;
 184 import org.simantics.scl.compiler.types.Type;
 185 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
 186 import org.simantics.scl.reflection.ReflectionUtils;
 187 import org.simantics.scl.reflection.ValueNotFoundException;
 188 import org.simantics.scl.runtime.function.Function1;
 189 import org.simantics.scl.runtime.function.Function3;
 190 import org.simantics.utils.DataContainer;
 191 import org.simantics.utils.Development;
 192 import org.simantics.utils.datastructures.Pair;
 193 import org.simantics.utils.datastructures.collections.CollectionUtils;
 194
 195 import gnu.trove.map.hash.TObjectIntHashMap;
 196
 197 public class ReadGraphImpl implements ReadGraph {
 198
 199     final static boolean EMPTY_RESOURCE_CHECK = false;
 200
 201         final public CacheEntry parent;
 202         final public QueryProcessor processor;
 203
 204         final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
 205         final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
 206
 207         final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
 208
 209         public static void resetCounters() {
 210                 counters.clear();
 211         }
 212
 213         public static String listCounters(File file) throws IOException {
 214
 215                 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
 216
 217                 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
 218                         b.print(-p.second + " " + p.first + "\n");
 219                 }
 220
 221                 b.close();
 222
 223                 return "Dumped " + counters.size() + " queries.";
 224
 225         }
 226
 227         /*
 228          * Implementation of the interface ReadGraph
 229          */
 230         final public String getURI(final Resource resource)     throws AssumptionException, ValidationException, ServiceException {
 231
 232                 assert (resource != null);
 233
 234                 try {
 235
 236                         return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
 237
 238                 } catch (AssumptionException e) {
 239
 240                         throw new AssumptionException(e);
 241
 242                 } catch (ValidationException e) {
 243
 244                         throw new ValidationException(e);
 245
 246                 } catch (ServiceException e) {
 247
 248                         throw new ServiceException(e);
 249
 250                 } catch (DatabaseException e) {
 251
 252                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 253
 254                 }
 255
 256         }
 257
 258         final public String getPossibleURI(final Resource resource)     throws ValidationException,     ServiceException {
 259
 260                 assert (resource != null);
 261
 262                 try {
 263
 264                         return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
 265
 266                 } catch (ValidationException e) {
 267
 268                         throw new ValidationException(e);
 269
 270                 } catch (ServiceException e) {
 271
 272                         throw new ServiceException(e);
 273
 274                 } catch (DatabaseException e) {
 275
 276                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 277
 278                 }
 279
 280         }
 281
 282         final public Resource getResource(final String id)
 283                         throws ResourceNotFoundException, ValidationException,
 284                         ServiceException {
 285
 286                 assert (id != null);
 287
 288                 try {
 289
 290 //                      assert (id != null);
 291 //                      assert (procedure != null);
 292 //
 293 //                      processor.forResource(this, id, procedure);
 294 //
 295 ////                    return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
 296 ////                                    id));
 297
 298                         Integer rid = QueryCache.resultURIToResource(this, id, parent, null);
 299                         if(rid == 0) throw new ResourceNotFoundException(id);
 300                         return processor.querySupport.getResource(rid);
 301
 302                 } catch (ResourceNotFoundException e) {
 303
 304                         throw new ResourceNotFoundException(id, e);
 305
 306                 } catch (ValidationException e) {
 307
 308                         throw new ValidationException(e);
 309
 310                 } catch (ServiceException e) {
 311
 312                         throw new ServiceException(e);
 313
 314                 } catch (DatabaseException e) {
 315
 316                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 317
 318                 }
 319
 320         }
 321
 322         final public Resource getPossibleResource(final String id)
 323         throws ResourceNotFoundException, ValidationException,
 324         ServiceException {
 325
 326                 assert (id != null);
 327
 328                 try {
 329
 330                         return getResource(id);
 331
 332 //                      return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
 333 //                                      id));
 334
 335                 } catch (ResourceNotFoundException e) {
 336
 337                         return null;
 338
 339                 } catch (ValidationException e) {
 340
 341                         throw new ValidationException(e);
 342
 343                 } catch (ServiceException e) {
 344
 345                         throw new ServiceException(e);
 346
 347                 } catch (DatabaseException e) {
 348
 349                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 350
 351                 }
 352
 353         }
 354
 355         @Override
 356         public Map<String, Resource> getChildren(Resource resource) throws ValidationException, ServiceException {
 357
 358                 assert (resource != null);
 359
 360                 try {
 361
 362                         int rId = processor.querySupport.getId(resource);
 363                         return QueryCache.resultChildMap(this, rId, parent, null);
 364
 365                 } catch (ValidationException e) {
 366
 367                         throw new ValidationException(e);
 368
 369                 } catch (ServiceException e) {
 370
 371                         throw new ServiceException(e);
 372
 373                 } catch (DatabaseException e) {
 374
 375                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 376
 377                 }
 378
 379         }
 380
 381         final public Resource getRootLibrary() {
 382                 return processor.getRootLibraryResource();
 383         }
 384
 385         final public Resource getBuiltin(final String id)
 386                         throws ResourceNotFoundException, ServiceException {
 387
 388                 assert (id != null);
 389
 390                 try {
 391
 392                         return syncRequest(new Builtin(id));
 393
 394                 } catch (ResourceNotFoundException e) {
 395
 396                         throw new ResourceNotFoundException(id, e);
 397
 398                 } catch (ServiceException e) {
 399
 400                         throw new ServiceException(e);
 401
 402                 } catch (DatabaseException e) {
 403
 404                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 405
 406                 }
 407
 408         }
 409
 410         static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
 411
 412                 private static Throwable DONE = new Throwable();
 413
 414                 Throwable exception = null;
 415
 416                 final ResourceSupport support;
 417
 418                 public StatementReadProcedure(ResourceSupport support) {
 419                         this.support = support;
 420                 }
 421
 422                 @Override
 423                 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
 424                         add(s);
 425                         add(p);
 426                         add(o);
 427                 }
 428
 429                 @Override
 430                 public void finished(AsyncReadGraph graph) {
 431                         exception = DONE;
 432                 }
 433
 434                 @Override
 435                 public void exception(AsyncReadGraph graph, Throwable t) {
 436                         exception = t;
 437                 }
 438
 439                 public void checkAndThrow() throws DatabaseException {
 440                         if(exception != DONE) {
 441                                 if (exception instanceof DatabaseException)
 442                                         throw (DatabaseException) exception;
 443                                 else
 444                                         throw new DatabaseException(
 445                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
 446                                                         exception);
 447                         }
 448                 }
 449
 450                 public boolean done() {
 451                         return exception != null;
 452                 }
 453
 454                 @Override
 455                 public boolean contains(Object obj) {
 456                     if(!(obj instanceof InternalStatement))
 457                         return false;
 458                     InternalStatement statement = (InternalStatement)obj;
 459                     int s = statement.s;
 460                     int p = statement.p;
 461                     int o = statement.o;
 462                     for(int i=0;i<sizeInternal();i+=3)
 463                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 464                     return true;
 465                     return false;
 466                 }
 467
 468                 @SuppressWarnings("unchecked")
 469         @Override
 470                 public <T> T[] toArray(T[] a) {
 471                     int length = sizeInternal() / 3;
 472                     if(length > a.length) {
 473                         Class<?> arrayType = a.getClass();
 474                         a = (arrayType == Object[].class)
 475                                 ? (T[]) new Object[length]
 476                                 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
 477                     }
 478                     else {
 479                         for(int i=length;i<a.length;++i)
 480                             a[i] = null;
 481                     }
 482             for(int i=0,j=0;i<sizeInternal();i+=3,++j)
 483                 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
 484             return a;
 485                 }
 486
 487                 @Override
 488                 public boolean add(Statement e) {
 489                         throw new UnsupportedOperationException();
 490                 }
 491
 492                 @Override
 493                 public boolean remove(Object o) {
 494                         throw new UnsupportedOperationException();
 495                 }
 496
 497                 @Override
 498                 public boolean addAll(Collection<? extends Statement> c) {
 499                         throw new UnsupportedOperationException();
 500                 }
 501
 502                 class IteratorImpl implements ListIterator<Statement> {
 503
 504             int index;
 505
 506             public IteratorImpl(int index) {
 507                 this.index = index;
 508             }
 509
 510             @Override
 511             public boolean hasNext() {
 512                 return index < sizeInternal();
 513             }
 514
 515             @Override
 516             public Statement next() {
 517                 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 518                 index += 3;
 519                 return result;
 520             }
 521
 522             @Override
 523             public void remove() {
 524                 throw new Error("Not supported");
 525             }
 526
 527             @Override
 528             public boolean hasPrevious() {
 529                 return index > 0;
 530             }
 531
 532             @Override
 533             public Statement previous() {
 534                 index -= 3;
 535                 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 536                 return result;
 537             }
 538
 539             @Override
 540             public int nextIndex() {
 541                 return index/3;
 542             }
 543
 544             @Override
 545             public int previousIndex() {
 546                 return index/3-1;
 547             }
 548
 549             @Override
 550             public void set(Statement e) {
 551                 throw new UnsupportedOperationException();
 552             }
 553
 554             @Override
 555             public void add(Statement e) {
 556                 throw new UnsupportedOperationException();
 557             }
 558
 559         };
 560
 561                 @Override
 562                 public Iterator<Statement> iterator() {
 563                         return new IteratorImpl(0);
 564                 }
 565
 566                 @Override
 567                 public int size() {
 568                         return sizeInternal() / 3;
 569                 }
 570
 571                 @Override
 572                 public Object[] toArray() {
 573                     Object[] result = new Object[sizeInternal() / 3];
 574                     for(int i=0,j=0;j<sizeInternal();i++,j+=3)
 575                         result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
 576                         return result;
 577                 }
 578
 579         @Override
 580         public boolean addAll(int index, Collection<? extends Statement> c) {
 581             throw new UnsupportedOperationException();
 582         }
 583
 584         @Override
 585         public Statement get(int index) {
 586             index += 3;
 587             if(index < 0 || index >= sizeInternal())
 588                 throw new IndexOutOfBoundsException();
 589             return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 590         }
 591
 592         @Override
 593         public Statement set(int index, Statement element) {
 594             throw new UnsupportedOperationException();
 595         }
 596
 597         @Override
 598         public void add(int index, Statement element) {
 599             throw new UnsupportedOperationException();
 600         }
 601
 602         @Override
 603         public Statement remove(int index) {
 604             throw new UnsupportedOperationException();
 605         }
 606
 607         @Override
 608         public int indexOf(Object obj) {
 609             if(!(obj instanceof InternalStatement))
 610                 return -1;
 611             InternalStatement statement = (InternalStatement)obj;
 612             int s = statement.s;
 613             int p = statement.p;
 614             int o = statement.o;
 615             for(int i=0;i<sizeInternal();i+=3)
 616                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 617                     return i/3;
 618             return -1;
 619         }
 620
 621         @Override
 622         public int lastIndexOf(Object obj) {
 623             if(!(obj instanceof InternalStatement))
 624                 return -1;
 625             InternalStatement statement = (InternalStatement)obj;
 626             int s = statement.s;
 627             int p = statement.p;
 628             int o = statement.o;
 629             for(int i=sizeInternal()-3;i>=0;i-=3)
 630                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 631                     return i/3;
 632             return -1;
 633         }
 634
 635         @Override
 636         public ListIterator<Statement> listIterator() {
 637             return new IteratorImpl(0);
 638         }
 639
 640         @Override
 641         public ListIterator<Statement> listIterator(int index) {
 642             return new IteratorImpl(index*3);
 643         }
 644
 645         @Override
 646         public List<Statement> subList(int fromIndex, int toIndex) {
 647             if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
 648                 throw new IndexOutOfBoundsException();
 649             return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
 650         }
 651         }
 652
 653         @Override
 654         final public Collection<Statement> getStatements(final Resource subject,
 655                         final Resource relation)
 656                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 657
 658                 assert (subject != null);
 659                 assert (relation != null);
 660
 661                 try {
 662
 663                         StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
 664                         processor.forEachStatement(this, subject, relation, procedure);
 665                         procedure.checkAndThrow();
 666                         return procedure;
 667
 668                 } catch (DatabaseException e) {
 669
 670                         System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
 671
 672                         StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
 673                         processor.forEachStatement(this, subject, relation, procedure);
 674
 675                         return Collections.emptyList();
 676
 677 //                      throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
 678
 679                 }
 680
 681         }
 682
 683         @Override
 684         final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
 685                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 686
 687                 assert (subject != null);
 688                 assert (relation != null);
 689
 690                 try {
 691
 692                         return syncRequest(new ForEachAssertedStatement(subject, relation));
 693
 694                 } catch (ManyObjectsForFunctionalRelationException e) {
 695
 696                         throw new ManyObjectsForFunctionalRelationException(e);
 697
 698                 } catch (ServiceException e) {
 699
 700                         throw new ServiceException(e);
 701
 702                 } catch (DatabaseException e) {
 703
 704                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 705
 706                 }
 707
 708         }
 709
 710         @Override
 711         final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
 712
 713                 assert (subject != null);
 714
 715                 try {
 716
 717                         return processor.getPredicates(this, subject);
 718
 719 //                      AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 720 //                      processor.forEachPredicate(this, subject, procedure);
 721 //                      procedure.checkAndThrow();
 722 //                      return procedure;
 723
 724                 } catch (ServiceException e) {
 725
 726                         throw new ServiceException(e);
 727
 728                 } catch (DatabaseException e) {
 729
 730                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 731
 732                 }  catch (Throwable e) {
 733
 734             throw new ServiceException(e);
 735
 736                 }
 737
 738         }
 739
 740         @Override
 741         final public Collection<Resource> getPrincipalTypes(final Resource subject)
 742                         throws ServiceException {
 743
 744                 assert (subject != null);
 745
 746                 try {
 747
 748                         AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 749                         processor.forEachPrincipalType(this, subject, procedure);
 750                         procedure.checkAndThrow();
 751                         return procedure;
 752
 753                 } catch (ServiceException e) {
 754
 755                         throw new ServiceException(e);
 756
 757                 } catch (DatabaseException e) {
 758
 759                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 760
 761                 }
 762
 763         }
 764
 765         @Override
 766         final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
 767
 768                 assert (subject != null);
 769
 770                 try {
 771
 772                         return processor.getTypes(this, subject);
 773
 774                 } catch (ServiceException e) {
 775
 776                         throw new ServiceException(e);
 777
 778                 } catch (DatabaseException e) {
 779
 780                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 781
 782         } catch (Throwable e) {
 783
 784             throw new ServiceException(e);
 785
 786                 }
 787
 788         }
 789
 790         @Override
 791         final public Set<Resource> getSupertypes(final Resource subject)
 792                         throws ServiceException {
 793
 794                 assert (subject != null);
 795
 796                 try {
 797
 798                         SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
 799                         processor.forSupertypes(this, subject, procedure);
 800                         procedure.checkAndThrow();
 801                         return procedure.result;
 802
 803                 } catch (ServiceException e) {
 804
 805                         throw new ServiceException(e);
 806
 807                 } catch (DatabaseException e) {
 808
 809                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 810
 811                 }
 812
 813         }
 814
 815         @Override
 816         final public Set<Resource> getSuperrelations(final Resource subject)
 817                         throws ServiceException {
 818
 819                 assert (subject != null);
 820
 821                 try {
 822
 823                         SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
 824                         processor.forSuperrelations(this, subject, procedure);
 825                         procedure.checkAndThrow();
 826                         return procedure.result;
 827
 828                 } catch (ServiceException e) {
 829
 830                         throw new ServiceException(e);
 831
 832                 } catch (DatabaseException e) {
 833
 834                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 835
 836                 }
 837
 838         }
 839
 840         @Override
 841         public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
 842
 843                 try {
 844
 845                         SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
 846                         processor.forPossibleSuperrelation(this, subject, procedure);
 847                         procedure.checkAndThrow();
 848                         return procedure.result;
 849
 850                 } catch (ServiceException e) {
 851
 852                         throw new ServiceException(e);
 853
 854                 } catch (DatabaseException e) {
 855
 856                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 857
 858                 }
 859
 860         }
 861
 862         @Override
 863         final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
 864                         throws ServiceException {
 865
 866                 assert (subject != null);
 867                 assert (relation != null);
 868
 869                 if(Development.DEVELOPMENT) {
 870             if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
 871                 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
 872             }
 873             //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
 874                 }
 875
 876                 try {
 877
 878                         AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 879                         processor.forEachObject(this, subject, relation, procedure);
 880                         procedure.checkAndThrow();
 881                         return procedure;
 882
 883                 } catch (DatabaseException e) {
 884
 885                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 886
 887                 }
 888
 889         }
 890
 891         @Override
 892         final public Collection<Resource> getAssertedObjects(
 893                         final Resource subject, final Resource relation)
 894                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 895
 896         if (subject == null)
 897             throw new ArgumentException("Subject must not be null.");
 898         if (relation == null)
 899             throw new ArgumentException("Relation must not be null. Subject=" + subject);
 900
 901                 try {
 902
 903                         return syncRequest(new ForEachAssertedObject(subject, relation));
 904
 905                 } catch (ManyObjectsForFunctionalRelationException e) {
 906
 907                         throw new ManyObjectsForFunctionalRelationException(e);
 908
 909                 } catch (ServiceException e) {
 910
 911                         throw new ServiceException(e);
 912
 913                 } catch (DatabaseException e) {
 914
 915                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 916
 917                 }
 918
 919         }
 920
 921         @Override
 922         final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
 923
 924                 assert (relation != null);
 925
 926                 try {
 927
 928                         return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
 929
 930                 } catch (NoSingleResultException e) {
 931
 932                         throw new NoInverseException(e);
 933
 934                 } catch (ServiceException e) {
 935
 936                         throw new ServiceException(e);
 937
 938                 }
 939
 940         }
 941
 942         @Override
 943         final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
 944
 945                 if( subject == null) throw new IllegalArgumentException("subject can not be null");
 946                 if( relation == null) throw new IllegalArgumentException("relation can not be null");
 947
 948                 try {
 949                         int single = processor.getSingleObject(this, subject, relation);
 950                         if (single == 0) {
 951                                 if (EMPTY_RESOURCE_CHECK) {
 952                                         if (!hasStatement(subject)) {
 953                                                 throw new EmptyResourceException("Resource " + debugString(subject));
 954                                         }
 955                                 }
 956                                 throw new NoSingleResultException("No single object for subject " + debugString(subject)
 957                                                 + " and relation " + debugString(relation), single);
 958                         }
 959                         return processor.querySupport.getResource(single);
 960                 } catch (NoSingleResultException e) {
 961                         throw e;
 962                 } catch (DatabaseException e) {
 963                         throw new ServiceException(e);
 964                 }
 965         }
 966
 967         @Override
 968         final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
 969                 assert (subject != null);
 970                 assert (relation != null);
 971                 try {
 972                         Collection<Statement> statements = getStatements(subject, relation);
 973                         if (statements.size() == 1) {
 974                                 return statements.iterator().next();
 975                         } else {
 976                                 if (EMPTY_RESOURCE_CHECK)
 977                                         if (!hasStatement(subject))
 978                                                 throw new EmptyResourceException("Resource " + debugString(subject));
 979                                 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
 980                                                 + " and relation " + debugString(relation), statements.size());
 981                         }
 982                 } catch (ServiceException e) {
 983                         throw new ServiceException(e);
 984                 }
 985         }
 986
 987         @Override
 988         final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
 989                 assert (subject != null);
 990                 try {
 991                         ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
 992                         if (principalTypes.size() == 1) {
 993                             return principalTypes.get(0);
 994                         } else {
 995                             throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
 996                         }
 997                 } catch (ServiceException e) {
 998                         throw new ServiceException(e);
 999                 }
1000         }
1001
1002         @Override
1003         final public Resource getSingleType(final Resource subject,
1004                         final Resource baseType) throws NoSingleResultException,
1005                         ServiceException {
1006
1007                 assert (subject != null);
1008                 assert (baseType != null);
1009
1010                 try {
1011                         return syncRequest(new SingleType(subject, baseType));
1012                 } catch (DatabaseException e) {
1013                     throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
1014                 }
1015         }
1016
1017         @Override
1018         final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1019
1020                 assert (subject != null);
1021
1022                 try {
1023
1024                         Layer0 L0 = processor.getL0(this);
1025             int object = processor.getSingleObject(this, subject, L0.HasDataType);
1026             if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1027
1028             if(processor.isImmutable(object)) {
1029                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1030                         return getValue(subject, binding);
1031             } else {
1032                     byte[] dt = processor.getValue(this, object);
1033                     if(dt == null) throw new ServiceException("No data type for " + subject);
1034                     Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1035                     Binding binding = Bindings.getBinding(datatype);
1036                     return getValue(subject, binding);
1037             }
1038
1039         } catch (IOException e) {
1040
1041             throw new ServiceException(e);
1042
1043                 } catch (DoesNotContainValueException e) {
1044
1045                         throw new DoesNotContainValueException(e, subject);
1046
1047                 } catch (ServiceException e) {
1048
1049                         throw new ServiceException(e);
1050
1051                 } catch (DatabaseException e) {
1052
1053                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1054
1055         }
1056
1057         }
1058
1059     @Override
1060     final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1061
1062         assert (subject != null);
1063
1064         try {
1065
1066             Layer0 L0 = processor.getL0(this);
1067             int object = processor.getSingleObject(this, subject, L0.HasDataType);
1068             if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1069
1070             if(processor.isImmutable(object)) {
1071                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1072                 return new Variant(binding, getValue(subject, binding));
1073             } else {
1074                 byte[] dt = processor.getValue(this, object);
1075                 if(dt == null) throw new ServiceException("No data type for " + subject);
1076                 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1077                 Binding binding = Bindings.getBinding(datatype);
1078                 return new Variant(binding, getValue(subject, binding));
1079             }
1080
1081         } catch (IOException e) {
1082
1083             throw new ServiceException(e);
1084
1085         } catch (DoesNotContainValueException e) {
1086
1087             throw new DoesNotContainValueException(e, subject);
1088
1089         } catch (ServiceException e) {
1090
1091             throw new ServiceException(e);
1092
1093         } catch (DatabaseException e) {
1094
1095             throw new ServiceException(INTERNAL_ERROR_STRING, e);
1096
1097         }
1098         }
1099
1100         static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1101
1102         static {
1103                 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1104         }
1105
1106         final protected Serializer getSerializer(Binding binding) {
1107             return binding.serializer();
1108         }
1109
1110         @Override
1111         final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1112                         ServiceException {
1113
1114                 assert (subject != null);
1115
1116                 try {
1117
1118                         byte[] bytes = processor.getValue(this, subject);
1119                         if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1120
1121                         Serializer serializer = getSerializer(binding);
1122                         return (T)serializer.deserialize(bytes);
1123
1124                 } catch (DoesNotContainValueException e) {
1125
1126                         throw new DoesNotContainValueException(e);
1127
1128                 } catch (IOException e) {
1129
1130                         throw new ServiceException(e);
1131
1132                 } catch (DatabaseException e) {
1133
1134             throw new ServiceException(e);
1135
1136         } catch (BufferUnderflowException e) {
1137             // This is sometimes thrown when deserialize fails because wrong format.
1138             // For callers of this method this is just an service exception.
1139             throw new ServiceException(e);
1140         }
1141
1142         }
1143
1144         @Override
1145         final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1146                         DoesNotContainValueException, ServiceException {
1147
1148                 assert (subject != null);
1149                 assert (relation != null);
1150
1151                 try {
1152                         Resource object = getSingleObject(subject, relation);
1153                         return getValue(object);
1154                 } catch (NoSingleResultException e) {
1155                         throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1156                 } catch (DoesNotContainValueException e) {
1157                         try {
1158                                 Layer0 L0 = processor.getL0(this);
1159                                 Resource object = getPossibleObject(subject, relation);
1160                                 if(isInstanceOf(object, L0.Value)) {
1161                                         if(isInstanceOf(object, L0.Literal)) {
1162                                                 throw new DoesNotContainValueException(e);
1163                                         } else {
1164                                                 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1165                                         }
1166                                 } else {
1167                                         throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1168                                 }
1169                         } catch (DoesNotContainValueException e2) {
1170                                 throw e2;
1171                         } catch (DatabaseException e2) {
1172                                 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1173                         }
1174                 } catch (ServiceException e) {
1175                         throw new ServiceException(e);
1176                 }
1177         }
1178
1179     @Override
1180     final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1181             DoesNotContainValueException, ServiceException {
1182
1183         assert (subject != null);
1184         assert (relation != null);
1185
1186         try {
1187             Resource object = getSingleObject(subject, relation);
1188             return getVariantValue(object);
1189         } catch (NoSingleResultException e) {
1190             throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1191         } catch (DoesNotContainValueException e) {
1192             try {
1193                 Layer0 L0 = processor.getL0(this);
1194                 Resource object = getPossibleObject(subject, relation);
1195                 if(isInstanceOf(object, L0.Value)) {
1196                     if(isInstanceOf(object, L0.Literal)) {
1197                         throw new DoesNotContainValueException(e);
1198                     } else {
1199                         throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1200                     }
1201                 } else {
1202                     throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1203                 }
1204             } catch (DoesNotContainValueException e2) {
1205                 throw e2;
1206             } catch (DatabaseException e2) {
1207                 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1208             }
1209         } catch (ServiceException e) {
1210             throw new ServiceException(e);
1211         }
1212     }
1213
1214         @Override
1215         final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1216                         throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1217
1218                 assert (subject != null);
1219                 assert (relation != null);
1220
1221                 try {
1222                         Resource object = getSingleObject(subject, relation);
1223                         return getValue(object, binding);
1224                 } catch (NoSingleResultException e) {
1225                     String message = "";
1226                     try {
1227                     String subjectName = NameUtils.getSafeName(this, subject, true);
1228                     String relationName = NameUtils.getSafeName(this, relation, true);
1229                     message = "Subject: " + subjectName + ", Relation: " + relationName;
1230                     } catch (DatabaseException e2) {
1231
1232                     }
1233             throw new NoSingleResultException(message, e.getResultCount(), e);
1234                 } catch (DoesNotContainValueException e) {
1235                         throw new DoesNotContainValueException(e);
1236                 } catch (ServiceException e) {
1237                         throw new ServiceException(e);
1238                 }
1239         }
1240
1241         @Override
1242         final public <T> T adapt(final Resource resource, final Class<T> clazz)
1243                         throws AdaptionException, ValidationException, ServiceException {
1244
1245                 assert (resource != null);
1246                 assert (clazz != null);
1247
1248                 try {
1249
1250                         return syncRequest(new Adapter<T>(resource, clazz));
1251
1252                 } catch (AdaptionException e) {
1253
1254                         throw new AdaptionException(e);
1255
1256                 } catch (ValidationException e) {
1257
1258                         throw new ValidationException(e);
1259
1260                 } catch (ServiceException e) {
1261
1262                         throw new ServiceException(e);
1263
1264                 } catch (DatabaseException e) {
1265
1266                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1267
1268                 }
1269
1270         }
1271
1272         @Override
1273         final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1274                         throws AdaptionException, ValidationException, ServiceException {
1275
1276                 assert (resource != null);
1277                 assert (context != null);
1278
1279                 class ContextualAdapter implements AsyncRead<T> {
1280
1281                         final private Resource resource;
1282                         final private C context;
1283                     final private Class<T> clazz;
1284
1285                     @Override
1286                     public int hashCode() {
1287                         return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1288                     }
1289
1290                     @Override
1291                     final public int threadHash() {
1292                         return resource.getThreadHash();
1293                     }
1294
1295                     @Override
1296                     public boolean equals(Object object) {
1297                         if (this == object)
1298                             return true;
1299                         else if (object == null)
1300                             return false;
1301                         else if (getClass() != object.getClass())
1302                             return false;
1303                         ContextualAdapter r = (ContextualAdapter)object;
1304                         return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1305                     }
1306
1307                     @Override
1308                     public int getFlags() {
1309                         return 0;
1310                     }
1311
1312                     public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1313                         this.resource = resource;
1314                         this.context = context;
1315                         this.clazz = clazz;
1316                     }
1317
1318                     @Override
1319                     public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1320
1321                                 final AdaptionService service = getSession().peekService(AdaptionService.class);
1322                                 if (service == null)
1323                                         procedure.exception(graph, new ServiceException("No AdaptionService available"));
1324                                 else
1325                                         service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1326
1327                     }
1328
1329                     @Override
1330                     public String toString() {
1331                         return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1332                     }
1333
1334                 }
1335
1336                 try {
1337
1338                         return syncRequest(new ContextualAdapter(resource, context, clazz));
1339
1340                 } catch (AdaptionException e) {
1341
1342                         throw new AdaptionException(e);
1343
1344                 } catch (ValidationException e) {
1345
1346                         throw new ValidationException(e);
1347
1348                 } catch (ServiceException e) {
1349
1350                         throw new ServiceException(e);
1351
1352                 } catch (DatabaseException e) {
1353
1354                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1355
1356                 }
1357
1358         }
1359
1360         @Override
1361         final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1362                         throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1363
1364                 assert (resource != null);
1365                 assert (clazz != null);
1366
1367                 Statement stm = getSingleStatement(resource, relation);
1368
1369                 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1370
1371         }
1372
1373         @Override
1374         final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1375                         throws ValidationException, ServiceException {
1376
1377                 try {
1378                         return adaptRelated(resource, relation, clazz);
1379                 } catch (DatabaseException e) {
1380                         return null;
1381                 }
1382
1383         }
1384
1385         @Override
1386         final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1387                         throws ValidationException, ServiceException {
1388
1389                 assert (resource != null);
1390                 assert (context != null);
1391
1392                 class PossibleContextualAdapter implements AsyncRead<T> {
1393
1394                         final private Resource resource;
1395                         final private C context;
1396                     final private Class<T> clazz;
1397
1398                     @Override
1399                     public int hashCode() {
1400                         return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1401                     }
1402
1403                     @Override
1404                     final public int threadHash() {
1405                         return resource.getThreadHash();
1406                     }
1407
1408                     @Override
1409                     public boolean equals(Object object) {
1410                         if (this == object)
1411                             return true;
1412                         else if (object == null)
1413                             return false;
1414                         else if (getClass() != object.getClass())
1415                             return false;
1416                         PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1417                         return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1418                     }
1419
1420                     @Override
1421                     public int getFlags() {
1422                         return 0;
1423                     }
1424
1425                     public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1426                         this.resource = resource;
1427                         this.context = context;
1428                         this.clazz = clazz;
1429                     }
1430
1431                     @Override
1432                     public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1433
1434                                 final AdaptionService service = getSession().peekService(AdaptionService.class);
1435                                 if (service == null)
1436                                         procedure.exception(graph, new ServiceException("No AdaptionService available"));
1437                                 else
1438                                         service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1439
1440                     }
1441
1442                     @Override
1443                     public String toString() {
1444                         return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1445                     }
1446
1447                 }
1448
1449                 try {
1450
1451                         return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1452
1453                 } catch (ValidationException e) {
1454
1455                         throw new ValidationException(e);
1456
1457                 } catch (ServiceException e) {
1458
1459                         throw new ServiceException(e);
1460
1461                 } catch (DatabaseException e) {
1462
1463                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1464
1465                 }
1466
1467         }
1468
1469         @Override
1470         final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1471                         throws AdaptionException, ValidationException, ServiceException {
1472
1473                 assert (resource != null);
1474                 assert (clazz != null);
1475
1476                 try {
1477
1478                         return syncRequest(new UniqueAdapter<T>(resource, clazz));
1479
1480                 } catch (AdaptionException e) {
1481
1482                         throw new AdaptionException(e);
1483
1484                 } catch (ValidationException e) {
1485
1486                         throw new ValidationException(e);
1487
1488                 } catch (ServiceException e) {
1489
1490                         throw new ServiceException(e);
1491
1492                 } catch (DatabaseException e) {
1493
1494                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1495
1496                 }
1497
1498         }
1499
1500         @Override
1501         final public Resource getPossibleInverse(final Resource relation)
1502                         throws ServiceException {
1503
1504                 assert (relation != null);
1505
1506                 try {
1507
1508                         return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1509
1510                 } catch (ServiceException e) {
1511
1512                         throw new ServiceException(e);
1513
1514                 } catch (DatabaseException e) {
1515
1516                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1517
1518                 }
1519
1520         }
1521
1522         @Override
1523         public Resource getPossibleObject(final Resource subject, final Resource relation)
1524                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1525
1526                 assert (subject != null);
1527                 assert (relation != null);
1528
1529                 try {
1530
1531                     int result = processor.getSingleObject(this, subject, relation);
1532                     if(result == 0) return null;
1533
1534                     return processor.querySupport.getResource(result);
1535
1536              } catch (ManyObjectsForFunctionalRelationException e) {
1537
1538                  throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1539
1540                 } catch (DatabaseException e) {
1541
1542                         throw new ServiceException(e);
1543
1544                 }
1545
1546         }
1547
1548         @Override
1549         final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1550                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1551
1552                 assert (subject != null);
1553                 assert (relation != null);
1554
1555                 try {
1556
1557                         Collection<Statement> statements = getStatements(subject, relation);
1558                         if(statements.size() == 1) return statements.iterator().next();
1559                         else return null;
1560
1561                 } catch (ManyObjectsForFunctionalRelationException e) {
1562
1563                         throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1564
1565                 } catch (ServiceException e) {
1566
1567                         throw new ServiceException(e);
1568
1569                 }
1570
1571         }
1572
1573         @Override
1574         final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1575
1576                 assert (subject != null);
1577                 assert (baseType != null);
1578
1579                 try {
1580
1581                         AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1582                         forPossibleType(subject, baseType, procedure);
1583                         procedure.checkAndThrow();
1584                         return procedure.result;
1585
1586                 } catch (ServiceException e) {
1587
1588                         throw new ServiceException(e);
1589
1590                 } catch (DatabaseException e) {
1591
1592                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1593
1594                 }
1595
1596         }
1597
1598         @Override
1599         final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1600
1601                 assert (subject != null);
1602
1603                 try {
1604
1605                     int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1606                     if(object == 0) return null;
1607
1608             if(processor.isImmutable(object)) {
1609                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1610                         return getPossibleValue(subject, binding);
1611             } else {
1612                     byte[] dt = processor.getValue(this, object);
1613                     if(dt == null) return null;
1614                     Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1615                     Binding binding = Bindings.getBinding(datatype);
1616                     return getPossibleValue(subject, binding);
1617             }
1618
1619         } catch (IOException e) {
1620
1621             throw new ServiceException(e);
1622
1623                 } catch (ServiceException e) {
1624
1625                         throw new ServiceException(e);
1626
1627                 } catch (DatabaseException e) {
1628
1629                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1630
1631         }
1632
1633         }
1634
1635         @Override
1636         final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1637
1638                 assert (subject != null);
1639                 assert (binding != null);
1640
1641                 try {
1642
1643             byte[] dt = processor.getValue(this, subject);
1644             if(dt == null) return null;
1645                         Serializer serializer = getSerializer(binding);
1646             return (T)serializer.deserialize(dt);
1647
1648         } catch (IOException e) {
1649
1650             throw new ServiceException(e);
1651
1652                 } catch (BindingException e) {
1653
1654                         throw new BindingException(e);
1655
1656                 } catch (ServiceException e) {
1657
1658                         throw new ServiceException(e);
1659
1660                 } catch (DatabaseException e) {
1661                         e.printStackTrace();
1662                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1663         }
1664
1665         }
1666
1667         @Override
1668         public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1669                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1670
1671                 assert (subject != null);
1672                 assert (relation != null);
1673
1674                 try {
1675
1676                         Resource object = getPossibleObject(subject, relation);
1677                         if(object == null) return null;
1678                         else return getPossibleValue(object);
1679
1680                 } catch (ManyObjectsForFunctionalRelationException e) {
1681
1682                         throw new ManyObjectsForFunctionalRelationException(e);
1683
1684                 } catch (ServiceException e) {
1685
1686                         throw new ServiceException(e);
1687
1688                 }
1689
1690         }
1691
1692         @Override
1693         public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1694                         throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1695
1696                 assert (subject != null);
1697                 assert (relation != null);
1698                 assert (binding != null);
1699
1700                 try {
1701
1702                         Resource object = getPossibleObject(subject, relation);
1703                         if(object == null) return null;
1704                         else return getPossibleValue(object, binding);
1705
1706                 } catch (ManyObjectsForFunctionalRelationException e) {
1707
1708                         throw new ManyObjectsForFunctionalRelationException(e);
1709
1710                 } catch (BindingException e) {
1711
1712                         throw new BindingException(e);
1713
1714                 } catch (ServiceException e) {
1715
1716                         throw new ServiceException(e);
1717
1718                 }
1719
1720         }
1721
1722         @Override
1723         public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1724
1725                 assert (resource != null);
1726                 assert (clazz != null);
1727
1728                 try {
1729
1730                         return syncRequest(new PossibleAdapter<T>(resource, clazz));
1731
1732                 } catch (ValidationException e) {
1733
1734                         throw new ValidationException(e);
1735
1736                 } catch (AdaptionException e) {
1737
1738                         return null;
1739
1740                 } catch (DatabaseException e) {
1741
1742                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1743
1744                 }
1745         }
1746
1747         @Override
1748         public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1749
1750                 assert (resource != null);
1751                 assert (clazz != null);
1752
1753                 try {
1754
1755                         return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1756
1757                 } catch (AdaptionException e) {
1758
1759                         return null;
1760
1761                 } catch (ValidationException e) {
1762
1763                         throw new ValidationException(e);
1764
1765                 } catch (DatabaseException e) {
1766
1767                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1768
1769                 }
1770
1771         }
1772
1773     @Override
1774     final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1775
1776         assert (resource != null);
1777         assert (type != null);
1778
1779         Set<Resource> resources = getTypes(resource);
1780         // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1781         if (null == resources)
1782             return false;
1783
1784         if(EMPTY_RESOURCE_CHECK) {
1785             if (resources.isEmpty()) {
1786                 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1787             }
1788         }
1789
1790         return resources.contains(type);
1791
1792     }
1793
1794         @Override
1795         final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1796
1797                 assert (resource != null);
1798                 assert (type != null);
1799
1800                 try {
1801
1802                         if(resource.equals(type)) return true;
1803
1804                         return getSupertypes(resource).contains(type);
1805
1806                 } catch (ServiceException e) {
1807
1808                         throw new ServiceException(e);
1809
1810                 }
1811
1812         }
1813
1814         @Override
1815         final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1816
1817                 assert (resource != null);
1818                 assert (type != null);
1819
1820                 try {
1821
1822                         if(resource.equals(type)) return true;
1823
1824                         return getSuperrelations(resource).contains(type);
1825
1826                 } catch (ServiceException e) {
1827
1828                         throw new ServiceException(e);
1829
1830                 }
1831
1832         }
1833
1834         @Override
1835         final public boolean hasStatement(final Resource subject) throws ServiceException {
1836
1837                 assert (subject != null);
1838
1839                 try {
1840
1841                         SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1842                         processor.forHasStatement(this, subject, procedure);
1843                         procedure.checkAndThrow();
1844                         return procedure.result;
1845
1846                 } catch (ServiceException e) {
1847
1848                         throw new ServiceException(e);
1849
1850                 } catch (DatabaseException e) {
1851
1852                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1853
1854                 }
1855
1856         }
1857
1858         @Override
1859         final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1860
1861                 assert (subject != null);
1862                 assert (relation != null);
1863
1864                 try {
1865
1866                         Collection<Resource> objects = getObjects(subject, relation);
1867                         return !objects.isEmpty();
1868
1869                 } catch (ServiceException e) {
1870
1871                         throw new ServiceException(e);
1872
1873                 }
1874
1875         }
1876
1877         @Override
1878         final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1879
1880                 assert (subject != null);
1881                 assert (relation != null);
1882                 assert (object != null);
1883
1884                 try {
1885
1886                         for(Resource o : getObjects(subject, relation)) {
1887                                 if(object.equals(o)) return true;
1888                         }
1889
1890                         return false;
1891
1892                 } catch (ServiceException e) {
1893
1894                         throw new ServiceException(e);
1895
1896                 }
1897
1898         }
1899
1900         @Override
1901         final public boolean hasValue(final Resource subject) throws ServiceException {
1902
1903                 assert (subject != null);
1904
1905                 try {
1906
1907                         SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1908                         processor.forHasValue(this, subject, procedure);
1909                         procedure.checkAndThrow();
1910                         return procedure.result;
1911
1912                 } catch (ServiceException e) {
1913
1914                         throw new ServiceException(e);
1915
1916                 } catch (DatabaseException e) {
1917
1918                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1919
1920                 }
1921
1922         }
1923
1924         final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1925
1926                 @Override
1927                 public void execute(AsyncReadGraph graph, Object result) {
1928                 }
1929
1930                 @Override
1931                 public void exception(AsyncReadGraph graph, Throwable throwable) {
1932                 }
1933
1934         };
1935
1936         /*
1937          * Implementation of the interface RequestProcessor
1938          */
1939
1940         @Override
1941         public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1942
1943                 assert (request != null);
1944
1945                 return QueryCache.resultReadEntry(this, request, parent, null, null);
1946
1947                 //return processor.query(this, request, parent, null, null);
1948
1949 //              if (parent != null) {
1950 //
1951 //                      try {
1952 //                      } catch (Throwable e) {
1953 //                              if(e instanceof DatabaseException) throw (DatabaseException)e;
1954 //                              else throw new DatabaseException(e);
1955 //                      }
1956 //
1957 //              } else {
1958 //
1959 //                      try {
1960 //
1961 //                              return processor.tryQuery(this, request);
1962 //
1963 //                      } catch (Throwable throwable) {
1964 //
1965 //                              //Logger.defaultLogError("Internal read request failure", throwable);
1966 //
1967 //                              if (throwable instanceof DatabaseException)
1968 //                                      throw (DatabaseException) throwable;
1969 //                              else
1970 //                                      throw new DatabaseException(
1971 //                                                      "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1972 //                                                      throwable);
1973 //
1974 //                      }
1975 //
1976 //              }
1977
1978         }
1979
1980         @Override
1981         public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1982                         throws DatabaseException {
1983                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1984         }
1985
1986         @Override
1987         public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1988                         throws DatabaseException {
1989                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1990         }
1991
1992         @Override
1993         public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1994
1995                 assert (request != null);
1996
1997                 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1998
1999                 return QueryCache.resultReadEntry(this, request, parent, listener, procedure);
2000
2001 //        return processor.query(this, request, parent, procedure, listener);
2002
2003
2004 //              if (parent != null || listener != null) {
2005 //
2006 //                      try {
2007 //            } catch (Throwable e) {
2008 //                if(e instanceof DatabaseException) throw (DatabaseException)e;
2009 //                else throw new DatabaseException(e);
2010 //            }
2011 //
2012 //              } else {
2013 //
2014 //                      try {
2015 //
2016 //                              T t = processor.tryQuery(this, request);
2017 //                              if(procedure != null)
2018 //                                      procedure.execute(this, t);
2019 //
2020 //                              return t;
2021 //
2022 //                      } catch (Throwable throwable) {
2023 //
2024 //                              Logger.defaultLogError("Internal read request failure", throwable);
2025 //
2026 //                              if(procedure != null)
2027 //                                      procedure.exception(this, throwable);
2028 //
2029 //                              if (throwable instanceof DatabaseException)
2030 //                                      throw (DatabaseException) throwable;
2031 //                              else
2032 //                                      throw new DatabaseException(
2033 //                                                      "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
2034 //                                                      throwable);
2035 //
2036 //                      }
2037 //
2038 //              }
2039
2040         }
2041
2042         @Override
2043         public <T> T syncRequest(final Read<T> request,
2044                         final SyncProcedure<T> procedure) throws DatabaseException {
2045                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2046         }
2047
2048         @Override
2049         public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2050                         throws DatabaseException {
2051                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2052         }
2053
2054         static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2055
2056                 private static Throwable DONE = new Throwable();
2057
2058                 T result = null;
2059                 Throwable exception = null;
2060
2061                 @Override
2062                 public void execute(AsyncReadGraph graph, T t) {
2063                         result = t;
2064                         exception = DONE;
2065                 }
2066
2067                 @Override
2068                 public void exception(AsyncReadGraph graph, Throwable t) {
2069                         exception = t;
2070                 }
2071
2072                 public void checkAndThrow() throws DatabaseException {
2073                         if(exception != DONE) {
2074                                 if (exception instanceof DatabaseException)
2075                                         throw (DatabaseException) exception;
2076                                 else
2077                                         throw new DatabaseException(
2078                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncRead)",
2079                                                         exception);
2080                         }
2081                 }
2082
2083                 public boolean done() {
2084                         return exception != null;
2085                 }
2086
2087         }
2088
2089         @Override
2090         public <T> T syncRequest(final AsyncRead<T> request)
2091                         throws DatabaseException {
2092
2093                 assert (request != null);
2094 //              AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2095                 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, null, request);
2096                 syncRequest(request, ap);
2097                 return ap.get();
2098 //              procedure.checkAndThrow();
2099 //              return procedure.result;
2100
2101 //              return syncRequest(request, new AsyncProcedureAdapter<T>());
2102
2103         }
2104
2105         @Override
2106         public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2107                         throws DatabaseException {
2108                 return syncRequest(request, (AsyncProcedure<T>) procedure);
2109         }
2110
2111         @Override
2112         public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2113                         throws DatabaseException {
2114                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2115         }
2116
2117         @Override
2118         public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2119                         throws DatabaseException {
2120                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2121         }
2122
2123         @Override
2124         final public <T> T syncRequest(final AsyncRead<T> request,
2125                         final AsyncProcedure<T> procedure) throws DatabaseException {
2126
2127                 assert (request != null);
2128
2129                 ListenerBase listener = getListenerBase(procedure);
2130
2131                 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
2132
2133 //              final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2134 //                              procedure, request);
2135
2136                 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
2137
2138                 //processor.query(this, request, parent, wrapper, listener);
2139
2140                 return ap.get();
2141
2142 //              return wrapper.getResult();
2143
2144 //              if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2145 //
2146 ////                    Object syncParent = request;
2147 //
2148 ////                    final ReadGraphImpl newGraph = newSync();
2149 //
2150 //
2151 ////                    newGraph.waitAsync(syncParent);
2152 //
2153 //                      Throwable e = wrapper.getException();
2154 //                      if (e != null) {
2155 //                              // The request was async - produce meaningful stack trace by
2156 //                              // wrapping
2157 //                              if (e instanceof DatabaseException)
2158 //                                      throw (DatabaseException) e;
2159 //                              else
2160 //                                      throw new DatabaseException(e);
2161 //                      }
2162 //
2163 //                      return wrapper.getResult();
2164 //
2165 //              } else {
2166 //
2167 //                      // System.out.println("direct call " + request );
2168 //
2169 //                      // Do not set the sync state.parent for external threads
2170 ////                    Object syncParent = request;
2171 //
2172 ////                    final ReadGraphImpl newGraph = newSync();
2173 //
2174 //                      final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2175 //                                      procedure, request);
2176 //
2177 //                      try {
2178 //
2179 //                              processor.tryQuery(this, request, wrapper);
2180 //
2181 //                      } catch (Throwable t) {
2182 //
2183 //                              wrapper.exception(this, t);
2184 //
2185 //                      }
2186 //
2187 //                      Throwable e = wrapper.getException();
2188 //                      if (e != null) {
2189 //                              // The request was async - produce meaningful stack trace by
2190 //                              // wrapping
2191 //                              if (e instanceof DatabaseException)
2192 //                                      throw (DatabaseException) e;
2193 //                              else
2194 //                                      throw new DatabaseException(e);
2195 //                      }
2196 //
2197 //                      return wrapper.getResult();
2198 //
2199 //              }
2200
2201         }
2202
2203         final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2204
2205                 assert (request != null);
2206
2207                 ListenerBase listener = getListenerBase(procedure);
2208                 assert(listener == null);
2209
2210                 BlockingAsyncProcedure<T> ap = new BlockingAsyncProcedure<>(this, procedure, request);
2211
2212 //              final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2213 //                              procedure, request);
2214
2215                 QueryCache.runnerAsyncReadEntry(this, request, parent, listener, ap, true);
2216
2217                 ap.get();
2218
2219         }
2220
2221         @Override
2222         public <T> T syncRequest(AsyncRead<T> request,
2223                         final SyncProcedure<T> procedure) throws DatabaseException {
2224                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2225         }
2226
2227         @Override
2228         final public <T> T syncRequest(final AsyncRead<T> request,
2229                         final Procedure<T> procedure) throws DatabaseException {
2230                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2231         }
2232
2233         @Override
2234         public <T> Collection<T> syncRequest(final MultiRead<T> request)
2235                         throws DatabaseException {
2236
2237                 assert (request != null);
2238
2239                 final ArrayList<T> result = new ArrayList<T>();
2240                 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2241
2242                 syncRequest(request, new AsyncMultiProcedure<T>() {
2243
2244                         @Override
2245                         public void execute(AsyncReadGraph graph, T t) {
2246                                 synchronized (result) {
2247                                         result.add(t);
2248                                 }
2249                         }
2250
2251                         @Override
2252                         public void finished(AsyncReadGraph graph) {
2253                         }
2254
2255                         @Override
2256                         public void exception(AsyncReadGraph graph, Throwable t) {
2257                                 exception.set(t);
2258                         }
2259
2260                         @Override
2261                         public String toString() {
2262                                 return "syncRequest(MultiRead) -> " + request;
2263                         }
2264
2265                 });
2266
2267                 Throwable t = exception.get();
2268                 if (t != null) {
2269                         if (t instanceof DatabaseException)
2270                                 throw (DatabaseException) t;
2271                         else
2272                                 throw new DatabaseException(
2273                                                 "Unexpected exception in ReadGraph.syncRequest(Read)",
2274                                                 t);
2275                 }
2276
2277                 return result;
2278
2279         }
2280
2281         @Override
2282         public <T> Collection<T> syncRequest(MultiRead<T> request,
2283                         AsyncMultiListener<T> procedure) {
2284                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2285         }
2286
2287         @Override
2288         public <T> Collection<T> syncRequest(MultiRead<T> request,
2289                         SyncMultiListener<T> procedure) {
2290                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2291         }
2292
2293         @Override
2294         public <T> Collection<T> syncRequest(MultiRead<T> request,
2295                         MultiListener<T> procedure) {
2296                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2297         }
2298
2299         @Override
2300         public <T> Collection<T> syncRequest(MultiRead<T> request,
2301                         AsyncMultiProcedure<T> procedure) {
2302
2303                 assert (request != null);
2304
2305                 ListenerBase listener = getListenerBase(procedure);
2306
2307                 if (parent != null || listener != null) {
2308
2309 //                      Object syncParent = request;
2310
2311 //                      final ReadGraphImpl newGraph = newSync();
2312
2313                         processor.query(this, request, parent, procedure, listener);
2314
2315 //                      newGraph.waitAsync(syncParent);
2316
2317                 } else {
2318
2319 //                      Object syncParent = request;
2320
2321 //                      final ReadGraphImpl newGraph = newSync();
2322
2323                         final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2324
2325                         try {
2326
2327                                 request.perform(this, wrapper);
2328
2329                         } catch (Throwable t) {
2330
2331                                 wrapper.exception(this, t);
2332 //                              newGraph.waitAsync(syncParent);
2333
2334                         }
2335
2336                 }
2337
2338                 // TODO
2339                 return null;
2340
2341         }
2342
2343         @Override
2344         public <T> Collection<T> syncRequest(MultiRead<T> request,
2345                         SyncMultiProcedure<T> procedure) {
2346                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2347         }
2348
2349         @Override
2350         public <T> Collection<T> syncRequest(MultiRead<T> request,
2351                         MultiProcedure<T> procedure) {
2352                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2353         }
2354
2355         static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2356
2357                 private static Throwable DONE = new Throwable();
2358
2359                 private static final long serialVersionUID = -6494230465108115812L;
2360
2361                 Throwable exception = null;
2362
2363                 @Override
2364                 public synchronized void execute(AsyncReadGraph graph, T t) {
2365                         add(t);
2366                 }
2367
2368                 @Override
2369                 public void finished(AsyncReadGraph graph) {
2370                         exception = DONE;
2371                 }
2372
2373                 @Override
2374                 public void exception(AsyncReadGraph graph, Throwable t) {
2375                         exception = t;
2376                 }
2377
2378                 public void checkAndThrow() throws DatabaseException {
2379                         if(exception != DONE) {
2380                                 if (exception instanceof DatabaseException)
2381                                         throw (DatabaseException) exception;
2382                                 else
2383                                         throw new DatabaseException(
2384                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2385                                                         exception);
2386                         }
2387                 }
2388
2389                 public boolean done() {
2390                         return exception != null;
2391                 }
2392
2393         }
2394
2395         @Override
2396         final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2397                         throws DatabaseException {
2398
2399                 assert (request != null);
2400
2401                 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2402
2403                 syncRequest(request, procedure);
2404
2405                 procedure.checkAndThrow();
2406                 return procedure;
2407
2408         }
2409
2410         @Override
2411         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2412                         AsyncMultiListener<T> procedure) {
2413                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2414         }
2415
2416         @Override
2417         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2418                         SyncMultiListener<T> procedure) {
2419                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2420         }
2421
2422         @Override
2423         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2424                         MultiListener<T> procedure) {
2425                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2426         }
2427
2428         final private <T> void syncRequest(final AsyncMultiRead<T> request,
2429                         final AsyncMultiReadProcedure<T> procedure) {
2430
2431                 assert (request != null);
2432                 assert (procedure != null);
2433
2434                 ListenerBase listener = getListenerBase(procedure);
2435
2436                 if (parent != null || listener != null) {
2437
2438 //                      Object syncParent = request;
2439
2440 //                      final ReadGraphImpl newGraph = newSync();
2441
2442                         processor.query(this, request, parent, procedure, listener);
2443
2444 //                      newGraph.waitAsync(syncParent);
2445                         waitAsyncProcedure(procedure);
2446
2447                 } else {
2448
2449 //                      Object syncParent = callerThread == Integer.MIN_VALUE ? null
2450 //                                      : request;
2451 //
2452 //                      final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2453
2454                         try {
2455
2456 //                              inc();
2457 //                              ReadGraphImpl sync = newSync();
2458                                 request.perform(this, procedure);
2459 //                              sync.waitAsync(null);
2460                                 waitAsyncProcedure(procedure);
2461 //                              dec();
2462
2463                         } catch (Throwable t) {
2464
2465                                 waitAsyncProcedure(procedure);
2466 //                              dec();
2467
2468                         }
2469
2470                 }
2471
2472         }
2473
2474
2475         @Override
2476         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2477                         final AsyncMultiProcedure<T> procedure) {
2478
2479                 assert (request != null);
2480                 assert (procedure != null);
2481
2482                 ListenerBase listener = getListenerBase(procedure);
2483
2484                 if (parent != null || listener != null) {
2485
2486 //                      Object syncParent = request;
2487
2488 //                      final ReadGraphImpl newGraph = newSync();
2489
2490                         processor.query(this, request, parent, procedure, listener);
2491
2492 //                      newGraph.waitAsync(syncParent);
2493
2494                 } else {
2495
2496 //                      Object syncParent = request;
2497
2498 //                      final ReadGraphImpl newGraph = newSync();
2499
2500                         try {
2501
2502                                 request.perform(this, new AsyncMultiProcedure<T>() {
2503
2504                                         @Override
2505                                         public void execute(AsyncReadGraph graph, T result) {
2506                                                 procedure.execute(graph, result);
2507                                         }
2508
2509                                         @Override
2510                                         public void finished(AsyncReadGraph graph) {
2511                                                 procedure.finished(graph);
2512                                         }
2513
2514                                         @Override
2515                                         public void exception(AsyncReadGraph graph, Throwable t) {
2516                                                 procedure.exception(graph, t);
2517                                         }
2518
2519                                         @Override
2520                                         public String toString() {
2521                                                 return "syncRequest(AsyncMultiRead) -> " + procedure;
2522                                         }
2523
2524                                 });
2525
2526                         } catch (Throwable t) {
2527
2528                         }
2529
2530                 }
2531
2532                 // TODO!!
2533                 return null;
2534
2535         }
2536
2537         @Override
2538         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2539                         final SyncMultiProcedure<T> procedure) {
2540                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2541         }
2542
2543         @Override
2544         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2545                         final MultiProcedure<T> procedure) {
2546                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2547         }
2548
2549         @Override
2550         public <T> T syncRequest(final ExternalRead<T> request)
2551                         throws DatabaseException {
2552
2553                 assert (request != null);
2554
2555                 return syncRequest(request, new Procedure<T>() {
2556
2557                         @Override
2558                         public void execute(T t) {
2559                         }
2560
2561                         @Override
2562                         public void exception(Throwable t) {
2563                         }
2564
2565                         @Override
2566                         public String toString() {
2567                                 return "syncRequest(AsyncRead) -> " + request;
2568                         }
2569
2570                 });
2571
2572         }
2573
2574         @Override
2575         public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2576                 return syncRequest(request, (Procedure<T>) procedure);
2577         }
2578
2579         @Override
2580         final public <T> T syncRequest(final ExternalRead<T> request,
2581                         final Procedure<T> procedure) throws DatabaseException {
2582
2583         assert (request != null);
2584
2585         ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
2586         return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2587
2588 //
2589 //          ListenerBase listener = getListenerBase(procedure);
2590 //
2591 //          return QueryCache.resultExternalReadEntry(this, request, parent, listener, procedure);
2592
2593 //              assert (request != null);
2594 //
2595 //              ListenerBase listener = getListenerBase(procedure);
2596 //
2597 //              final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2598 //              final DataContainer<T> result = new DataContainer<T>();
2599 //
2600 //              processor.query(this, request, parent, new Procedure<T>() {
2601 //
2602 //                      @Override
2603 //                      public void exception(Throwable throwable) {
2604 //                              exception.set(throwable);
2605 //                              procedure.exception(throwable);
2606 //                      }
2607 //
2608 //                      @Override
2609 //                      public void execute(T t) {
2610 //                              result.set(t);
2611 //                              procedure.execute(t);
2612 //                      }
2613 //
2614 //              }, listener);
2615
2616
2617
2618 //              if (parent != null || listener != null) {
2619 //
2620 ////                    final ReadGraphImpl newGraph = newSync();
2621 //
2622 //
2623 ////                    newGraph.waitAsync(request);
2624 //
2625 //              } else {
2626 //
2627 //                      try {
2628 //
2629 //                              T t = processor.tryQuery(this, request);
2630 //                              result.set(t);
2631 //                              procedure.execute(t);
2632 //
2633 //                      } catch (Throwable t) {
2634 //
2635 //                          if (t instanceof DatabaseException) {
2636 //                              exception.set((DatabaseException)t);
2637 //                              procedure.exception(exception.get());
2638 //                          } else {
2639 //                              exception.set(new DatabaseException(
2640 //                                      "Unexpected exception in ReadGraph.syncRequest(Read)",
2641 //                                      t));
2642 //                              procedure.exception(exception.get());
2643 //                          }
2644 //
2645 //                      }
2646 //
2647 //              }
2648 //
2649 //              Throwable t = exception.get();
2650 //              if (t != null) {
2651 //                      if (t instanceof DatabaseException)
2652 //                              throw (DatabaseException) t;
2653 //                      else
2654 //                              throw new DatabaseException(
2655 //                                              "Unexpected exception in ReadGraph.syncRequest(Read)",
2656 //                                              t);
2657 //              }
2658 //
2659 //              return result.get();
2660
2661         }
2662
2663         @Override
2664         public void syncRequest(final Write request) throws DatabaseException {
2665
2666                 assert (request != null);
2667
2668                 throw new DatabaseException(
2669                                 "Write operations are not supported during read transactions!");
2670
2671         }
2672
2673         @Override
2674         public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2675
2676                 assert (request != null);
2677
2678                 throw new DatabaseException(
2679                                 "Write operations are not supported during read transactions!");
2680
2681         }
2682
2683         @Override
2684         public void syncRequest(final DelayedWrite request)
2685                         throws DatabaseException {
2686
2687                 assert (request != null);
2688
2689                 throw new DatabaseException(
2690                                 "Write operations are not supported during read transactions!");
2691
2692         }
2693
2694         @Override
2695         public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2696
2697                 assert (request != null);
2698
2699                 throw new DatabaseException(
2700                                 "Write operations are not supported during read transactions!");
2701
2702         }
2703
2704         @Override
2705         public void syncRequest(final WriteOnly request) throws DatabaseException {
2706
2707                 assert (request != null);
2708
2709                 throw new DatabaseException(
2710                                 "Write operations are not supported during read transactions!");
2711
2712         }
2713
2714         @Override
2715         public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2716
2717                 assert (request != null);
2718
2719                 throw new DatabaseException(
2720                                 "Write operations are not supported during read transactions!");
2721
2722         }
2723
2724         @Override
2725         public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2726                 r.request(this, procedure);
2727         }
2728
2729         @Override
2730         public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2731                 r.request(this, procedure);
2732         }
2733
2734         @Override
2735         public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2736                 r.request(this, procedure);
2737         }
2738
2739         @Override
2740         public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2741                 r.request(this, procedure);
2742         }
2743
2744         @Override
2745         public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2746                 r.request(this, procedure);
2747         }
2748
2749         @Override
2750         public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2751                 r.request(this, procedure);
2752         }
2753
2754         @Override
2755         public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2756                 return r.request(this);
2757         }
2758
2759         @Override
2760         public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2761                 return r.request(this);
2762         }
2763
2764         @Override
2765         public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2766                 r.request(this, procedure);
2767         }
2768
2769         @Override
2770         public <T> void async(WriteInterface<T> r) {
2771                 r.request(this, new ProcedureAdapter<T>());
2772         }
2773
2774         /*
2775          * Implementation of the interface AsyncReadGraph
2776          */
2777
2778         @Override
2779         public void forURI(Resource resource, AsyncListener<String> listener) {
2780                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2781                                 listener);
2782         }
2783
2784         @Override
2785         public void forURI(Resource resource, SyncListener<String> listener) {
2786                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2787                                 listener);
2788         }
2789
2790         @Override
2791         public void forURI(Resource resource, Listener<String> listener) {
2792                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2793                                 listener);
2794         }
2795
2796         @Override
2797         final public void forURI(final Resource resource,
2798                         final AsyncProcedure<String> procedure) {
2799
2800                 assert (resource != null);
2801                 assert (procedure != null);
2802
2803                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2804                                 procedure);
2805
2806         }
2807
2808         @Override
2809         public void forURI(Resource resource, SyncProcedure<String> procedure) {
2810                 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2811         }
2812
2813         @Override
2814         public void forURI(Resource resource, Procedure<String> procedure) {
2815                 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2816         }
2817
2818         @Override
2819         public void forResource(String id, AsyncListener<Resource> listener) {
2820                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2821                                 listener);
2822         }
2823
2824         @Override
2825         public void forResource(String id, SyncListener<Resource> listener) {
2826                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2827                                 listener);
2828         }
2829
2830         @Override
2831         public void forResource(String id, Listener<Resource> listener) {
2832                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2833                                 listener);
2834         }
2835
2836         @Override
2837         final public void forResource(final String id,
2838                         final AsyncProcedure<Resource> procedure) {
2839
2840                 assert (id != null);
2841                 assert (procedure != null);
2842
2843                 processor.forResource(this, id, procedure);
2844
2845         }
2846
2847         @Override
2848         public void forResource(String id, SyncProcedure<Resource> procedure) {
2849                 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2850         }
2851
2852         @Override
2853         public void forResource(String id, Procedure<Resource> procedure) {
2854                 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2855         }
2856
2857         @Override
2858         public void forBuiltin(String id, AsyncListener<Resource> listener) {
2859                 asyncRequest(new Builtin(id), listener);
2860         }
2861
2862         @Override
2863         public void forBuiltin(String id, SyncListener<Resource> listener) {
2864                 asyncRequest(new Builtin(id), listener);
2865         }
2866
2867         @Override
2868         public void forBuiltin(String id, Listener<Resource> listener) {
2869                 asyncRequest(new Builtin(id), listener);
2870         }
2871
2872         @Override
2873         final public void forBuiltin(final String id,
2874                         final AsyncProcedure<Resource> procedure) {
2875
2876                 assert (id != null);
2877                 assert (procedure != null);
2878
2879                 processor.forBuiltin(this, id, procedure);
2880
2881         }
2882
2883         @Override
2884         public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2885                 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2886         }
2887
2888         @Override
2889         public void forBuiltin(String id, Procedure<Resource> procedure) {
2890                 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2891         }
2892
2893         @Override
2894         final public void forEachStatement(Resource subject, Resource relation,
2895                         AsyncMultiProcedure<Statement> procedure) {
2896
2897                 assert (subject != null);
2898                 assert (relation != null);
2899                 assert (procedure != null);
2900
2901                 processor.forEachStatement(this, subject, relation, procedure);
2902
2903         }
2904
2905         @Override
2906         public void forEachStatement(Resource subject, Resource relation,
2907                         SyncMultiProcedure<Statement> procedure) {
2908                 forEachStatement(subject, relation,
2909                                 new SyncToAsyncMultiProcedure<Statement>(procedure));
2910         }
2911
2912         @Override
2913         final public void forEachStatement(Resource subject, Resource relation,
2914                         MultiProcedure<Statement> procedure) {
2915
2916                 assert (subject != null);
2917                 assert (relation != null);
2918                 assert (procedure != null);
2919
2920                 processor.forEachStatement(this, subject, relation, procedure);
2921
2922         }
2923
2924         @Override
2925         final public void forStatementSet(Resource subject, Resource relation,
2926                         AsyncSetListener<Statement> procedure) {
2927
2928                 assert (subject != null);
2929                 assert (relation != null);
2930                 assert (procedure != null);
2931
2932                 processor.forStatementSet(this, subject, relation, procedure);
2933
2934         }
2935
2936         @Override
2937         final public void forStatementSet(Resource subject, Resource relation,
2938                         SyncSetListener<Statement> procedure) {
2939                 forStatementSet(subject, relation,
2940                                 new SyncToAsyncSetProcedure<Statement>(procedure));
2941         }
2942
2943         @Override
2944         public void forStatementSet(Resource subject, Resource relation,
2945                         SetListener<Statement> listener) {
2946                 forStatementSet(subject, relation,
2947                                 new NoneToAsyncSetProcedure<Statement>(listener));
2948         }
2949
2950         @Override
2951         final public void forEachAssertedStatement(final Resource subject,
2952                         final Resource relation,
2953                         final AsyncMultiProcedure<Statement> procedure) {
2954
2955                 assert (subject != null);
2956                 assert (relation != null);
2957                 assert (procedure != null);
2958
2959                 processor.forEachAssertedStatement(this, subject, relation, procedure);
2960
2961         }
2962
2963         @Override
2964         public void forEachAssertedStatement(Resource subject, Resource relation,
2965                         SyncMultiProcedure<Statement> procedure) {
2966                 forEachAssertedStatement(subject, relation,
2967                                 new SyncToAsyncMultiProcedure<Statement>(procedure));
2968         }
2969
2970         @Override
2971         public void forEachAssertedStatement(Resource subject, Resource relation,
2972                         MultiProcedure<Statement> procedure) {
2973                 forEachAssertedStatement(subject, relation,
2974                                 new NoneToAsyncMultiProcedure<Statement>(procedure));
2975         }
2976
2977         @Override
2978         public void forAssertedStatementSet(Resource subject, Resource relation,
2979                         AsyncSetListener<Statement> procedure) {
2980
2981                 assert (subject != null);
2982                 assert (relation != null);
2983                 assert (procedure != null);
2984
2985                 processor.forAssertedStatementSet(this, subject, relation, procedure);
2986
2987         }
2988
2989         @Override
2990         public void forAssertedStatementSet(Resource subject, Resource relation,
2991                         SyncSetListener<Statement> procedure) {
2992
2993                 assert (subject != null);
2994                 assert (relation != null);
2995                 assert (procedure != null);
2996
2997                 forAssertedStatementSet(subject, relation,
2998                                 new SyncToAsyncSetProcedure<Statement>(procedure));
2999
3000         }
3001
3002         @Override
3003         public void forAssertedStatementSet(Resource subject, Resource relation,
3004                         SetListener<Statement> procedure) {
3005
3006                 assert (subject != null);
3007                 assert (relation != null);
3008                 assert (procedure != null);
3009
3010                 forAssertedStatementSet(subject, relation,
3011                                 new NoneToAsyncSetProcedure<Statement>(procedure));
3012
3013         }
3014
3015         @Override
3016         final public void forEachPredicate(final Resource subject,
3017                         final AsyncMultiProcedure<Resource> procedure) {
3018
3019                 assert (subject != null);
3020                 assert (procedure != null);
3021
3022                 processor.forEachPredicate(this, subject, procedure);
3023
3024         }
3025
3026         @Override
3027         public void forEachPredicate(Resource subject,
3028                         SyncMultiProcedure<Resource> procedure) {
3029                 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
3030                                 procedure));
3031         }
3032
3033         @Override
3034         final public void forEachPredicate(final Resource subject,
3035                         final MultiProcedure<Resource> procedure) {
3036
3037                 assert (subject != null);
3038                 assert (procedure != null);
3039
3040                 processor.forEachPredicate(this, subject, procedure);
3041
3042         }
3043
3044         @Override
3045         final public void forPredicateSet(final Resource subject,
3046                         final AsyncSetListener<Resource> procedure) {
3047
3048                 assert (subject != null);
3049                 assert (procedure != null);
3050
3051                 processor.forPredicateSet(this, subject, procedure);
3052
3053         }
3054
3055         @Override
3056         final public void forPredicateSet(final Resource subject,
3057                         final SyncSetListener<Resource> procedure) {
3058
3059                 assert (subject != null);
3060                 assert (procedure != null);
3061
3062                 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3063                                 procedure));
3064
3065         }
3066
3067         @Override
3068         final public void forPredicateSet(final Resource subject,
3069                         final SetListener<Resource> procedure) {
3070
3071                 assert (subject != null);
3072                 assert (procedure != null);
3073
3074                 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3075                                 procedure));
3076
3077         }
3078
3079         @Override
3080         final public void forEachPrincipalType(final Resource subject,
3081                         final AsyncMultiProcedure<Resource> procedure) {
3082
3083                 assert (subject != null);
3084                 assert (procedure != null);
3085
3086                 processor.forEachPrincipalType(this, subject, procedure);
3087
3088         }
3089
3090         @Override
3091         public void forEachPrincipalType(Resource subject,
3092                         SyncMultiProcedure<Resource> procedure) {
3093                 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3094                                 procedure));
3095         }
3096
3097         @Override
3098         final public void forEachPrincipalType(final Resource subject,
3099                         final MultiProcedure<Resource> procedure) {
3100
3101                 assert (subject != null);
3102                 assert (procedure != null);
3103
3104                 processor.forEachPrincipalType(this, subject, procedure);
3105
3106         }
3107
3108         @Override
3109         final public void forPrincipalTypeSet(final Resource subject,
3110                         final AsyncSetListener<Resource> procedure) {
3111
3112                 assert (subject != null);
3113                 assert (procedure != null);
3114
3115                 processor.forPrincipalTypeSet(this, subject, procedure);
3116
3117         }
3118
3119         @Override
3120         final public void forPrincipalTypeSet(final Resource subject,
3121                         final SyncSetListener<Resource> procedure) {
3122
3123                 assert (subject != null);
3124                 assert (procedure != null);
3125
3126                 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3127                                 procedure));
3128
3129         }
3130
3131         @Override
3132         final public void forPrincipalTypeSet(final Resource subject,
3133                         final SetListener<Resource> procedure) {
3134
3135                 assert (subject != null);
3136                 assert (procedure != null);
3137
3138                 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3139                                 procedure));
3140
3141         }
3142
3143         @Override
3144         public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3145                 asyncRequest(new Types(subject), listener);
3146         }
3147
3148         @Override
3149         public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3150                 asyncRequest(new Types(subject), listener);
3151         }
3152
3153         @Override
3154         public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3155                 asyncRequest(new Types(subject), listener);
3156         }
3157
3158         @Override
3159         final public void forTypes(final Resource subject,
3160                         final AsyncProcedure<Set<Resource>> procedure) {
3161
3162                 assert (subject != null);
3163                 assert (procedure != null);
3164
3165                 processor.forTypes(this, subject, procedure);
3166
3167         }
3168
3169         @Override
3170         public void forTypes(Resource subject,
3171                         SyncProcedure<Set<Resource>> procedure) {
3172                 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3173         }
3174
3175         @Override
3176         public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3177                 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3178         }
3179
3180         @Override
3181         public void forSupertypes(Resource subject,
3182                         AsyncListener<Set<Resource>> listener) {
3183                 asyncRequest(new Types(subject), listener);
3184         }
3185
3186         @Override
3187         public void forSupertypes(Resource subject,
3188                         SyncListener<Set<Resource>> listener) {
3189                 asyncRequest(new Types(subject), listener);
3190         }
3191
3192         @Override
3193         public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3194                 asyncRequest(new Types(subject), listener);
3195         }
3196
3197         @Override
3198         final public void forSupertypes(final Resource subject,
3199                         final AsyncProcedure<Set<Resource>> procedure) {
3200
3201                 assert (subject != null);
3202                 assert (procedure != null);
3203
3204                 processor.forSupertypes(this, subject, procedure);
3205
3206         }
3207
3208         @Override
3209         public void forSupertypes(Resource subject,
3210                         SyncProcedure<Set<Resource>> procedure) {
3211                 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3212                                 procedure));
3213         }
3214
3215         @Override
3216         public void forSupertypes(Resource subject,
3217                         Procedure<Set<Resource>> procedure) {
3218                 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3219                                 procedure));
3220         }
3221
3222         @Override
3223         public void forDirectSuperrelations(Resource subject,
3224                         AsyncMultiProcedure<Resource> procedure) {
3225
3226                 assert (subject != null);
3227                 assert (procedure != null);
3228
3229                 processor.forDirectSuperrelations(this, subject, procedure);
3230
3231         }
3232
3233         @Override
3234         public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3235
3236                 assert (subject != null);
3237                 assert (procedure != null);
3238
3239                 processor.forPossibleSuperrelation(this, subject, procedure);
3240
3241         }
3242
3243         @Override
3244         public void forSuperrelations(Resource subject,
3245                         AsyncListener<Set<Resource>> listener) {
3246                 asyncRequest(new Types(subject), listener);
3247         }
3248
3249         @Override
3250         public void forSuperrelations(Resource subject,
3251                         SyncListener<Set<Resource>> listener) {
3252                 asyncRequest(new Types(subject), listener);
3253         }
3254
3255         @Override
3256         public void forSuperrelations(Resource subject,
3257                         Listener<Set<Resource>> listener) {
3258                 asyncRequest(new Types(subject), listener);
3259         }
3260
3261         @Override
3262         final public void forSuperrelations(final Resource subject,
3263                         final AsyncProcedure<Set<Resource>> procedure) {
3264
3265                 assert (subject != null);
3266                 assert (procedure != null);
3267
3268                 processor.forSuperrelations(this, subject, procedure);
3269
3270         }
3271
3272         @Override
3273         public void forSuperrelations(Resource subject,
3274                         SyncProcedure<Set<Resource>> procedure) {
3275                 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3276                                 procedure));
3277         }
3278
3279         @Override
3280         public void forSuperrelations(Resource subject,
3281                         Procedure<Set<Resource>> procedure) {
3282                 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3283                                 procedure));
3284         }
3285
3286         @Override
3287         final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3288                 processor.forEachObject(this, subject, relation, procedure);
3289         }
3290
3291         @Override
3292         public void forEachObject(Resource subject, Resource relation,
3293                         SyncMultiProcedure<Resource> procedure) {
3294                 forEachObject(subject, relation,
3295                                 new SyncToAsyncMultiProcedure<Resource>(procedure));
3296         }
3297
3298         @Override
3299         public void forEachObject(Resource subject, Resource relation,
3300                         MultiProcedure<Resource> procedure) {
3301
3302                 processor.forEachObject(this, subject, relation, procedure);
3303
3304         }
3305
3306 //      @Override
3307 //      final public void forEachDirectObject(final Resource subject,
3308 //                      final Resource relation,
3309 //                      final AsyncMultiProcedure<Resource> procedure) {
3310 //
3311 //              processor.forEachDirectObject(this, subject, relation, procedure);
3312 //
3313 //      }
3314 //
3315 //      @Override
3316 //      public void forEachDirectObject(Resource subject, Resource relation,
3317 //                      SyncMultiProcedure<Resource> procedure) {
3318 //              forEachDirectObject(subject, relation,
3319 //                              new SyncToAsyncMultiProcedure<Resource>(procedure));
3320 //      }
3321 //
3322 //      @Override
3323 //      public void forEachDirectObject(Resource subject, Resource relation,
3324 //                      MultiProcedure<Resource> procedure) {
3325 //              forEachDirectObject(subject, relation,
3326 //                              new NoneToAsyncMultiProcedure<Resource>(procedure));
3327 //      }
3328
3329         @Override
3330         final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3331                 processor.forEachDirectPredicate(this, subject, procedure);
3332         }
3333
3334         @Override
3335         public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3336                 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3337         }
3338
3339         @Override
3340         public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3341                 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3342         }
3343
3344         @Override
3345         final public void forObjectSet(final Resource subject,
3346                         final Resource relation, final AsyncSetListener<Resource> procedure) {
3347
3348                 assert (subject != null);
3349                 assert (relation != null);
3350                 assert (procedure != null);
3351
3352                 processor.forObjectSet(this, subject, relation, procedure);
3353
3354         }
3355
3356         @Override
3357         final public void forObjectSet(final Resource subject,
3358                         final Resource relation, final SyncSetListener<Resource> procedure) {
3359
3360                 assert (subject != null);
3361                 assert (relation != null);
3362                 assert (procedure != null);
3363
3364                 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3365                                 procedure));
3366
3367         }
3368
3369         @Override
3370         final public void forObjectSet(final Resource subject,
3371                         final Resource relation, final SetListener<Resource> procedure) {
3372
3373                 assert (subject != null);
3374                 assert (relation != null);
3375                 assert (procedure != null);
3376
3377                 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3378                                 procedure));
3379
3380         }
3381
3382         @Override
3383         final public void forEachAssertedObject(final Resource subject,
3384                         final Resource relation,
3385                         final AsyncMultiProcedure<Resource> procedure) {
3386
3387                 assert (subject != null);
3388                 assert (relation != null);
3389                 assert (procedure != null);
3390
3391                 processor.forEachAssertedObject(this, subject, relation, procedure);
3392
3393         }
3394
3395         @Override
3396         public void forEachAssertedObject(Resource subject, Resource relation,
3397                         SyncMultiProcedure<Resource> procedure) {
3398
3399                 assert (subject != null);
3400                 assert (relation != null);
3401                 assert (procedure != null);
3402
3403                 forEachAssertedObject(subject, relation,
3404                                 new SyncToAsyncMultiProcedure<Resource>(procedure));
3405
3406         }
3407
3408         @Override
3409         public void forEachAssertedObject(Resource subject, Resource relation,
3410                         MultiProcedure<Resource> procedure) {
3411
3412                 assert (subject != null);
3413                 assert (relation != null);
3414                 assert (procedure != null);
3415
3416                 forEachAssertedObject(subject, relation,
3417                                 new NoneToAsyncMultiProcedure<Resource>(procedure));
3418
3419         }
3420
3421         @Override
3422         public void forAssertedObjectSet(Resource subject, Resource relation,
3423                         AsyncSetListener<Resource> procedure) {
3424
3425                 assert (subject != null);
3426                 assert (relation != null);
3427                 assert (procedure != null);
3428
3429                 processor.forAssertedObjectSet(this, subject, relation, procedure);
3430
3431         }
3432
3433         @Override
3434         public void forAssertedObjectSet(Resource subject, Resource relation,
3435                         SyncSetListener<Resource> procedure) {
3436
3437                 assert (subject != null);
3438                 assert (relation != null);
3439                 assert (procedure != null);
3440
3441                 forAssertedObjectSet(subject, relation,
3442                                 new SyncToAsyncSetProcedure<Resource>(procedure));
3443
3444         }
3445
3446         @Override
3447         public void forAssertedObjectSet(Resource subject, Resource relation,
3448                         SetListener<Resource> procedure) {
3449
3450                 assert (subject != null);
3451                 assert (relation != null);
3452                 assert (procedure != null);
3453
3454                 forAssertedObjectSet(subject, relation,
3455                                 new NoneToAsyncSetProcedure<Resource>(procedure));
3456
3457         }
3458
3459         @Override
3460         public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3461                 asyncRequest(new Inverse(relation), listener);
3462         }
3463
3464         @Override
3465         public void forInverse(Resource relation, SyncListener<Resource> listener) {
3466                 asyncRequest(new Inverse(relation), listener);
3467         }
3468
3469         @Override
3470         public void forInverse(Resource relation, Listener<Resource> listener) {
3471                 asyncRequest(new Inverse(relation), listener);
3472         }
3473
3474         @Override
3475         final public void forInverse(final Resource relation,
3476                         final AsyncProcedure<Resource> procedure) {
3477
3478                 assert (relation != null);
3479                 assert (procedure != null);
3480
3481                 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3482
3483                         @Override
3484                         public void execute(AsyncReadGraph graph, Resource result) {
3485                                 if (result != null)
3486                                         procedure.execute(graph, result);
3487                                 else {
3488                                         procedure.exception(graph, new NoInverseException(relation
3489                                                         .toString()));
3490                                 }
3491                         }
3492
3493                         @Override
3494                         public void exception(AsyncReadGraph graph, Throwable throwable) {
3495                                 procedure.exception(graph, throwable);
3496                         }
3497
3498                         @Override
3499                         public String toString() {
3500                                 return "forInverse -> " + procedure;
3501                         }
3502
3503                 });
3504
3505         }
3506
3507         @Override
3508         public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3509                 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3510         }
3511
3512         @Override
3513         public void forInverse(Resource relation, Procedure<Resource> procedure) {
3514                 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3515         }
3516
3517         @Override
3518         public void forSingleObject(Resource subject, Resource relation,
3519                         AsyncListener<Resource> listener) {
3520                 asyncRequest(new SingleObject(subject, relation), listener);
3521         }
3522
3523         @Override
3524         public void forSingleObject(Resource subject, Resource relation,
3525                         SyncListener<Resource> listener) {
3526                 asyncRequest(new SingleObject(subject, relation), listener);
3527         }
3528
3529         @Override
3530         public void forSingleObject(Resource subject, Resource relation,
3531                         Listener<Resource> listener) {
3532                 asyncRequest(new SingleObject(subject, relation), listener);
3533         }
3534
3535         @Override
3536         final public void forSingleObject(final Resource subject,
3537                         final Resource relation, final AsyncProcedure<Resource> procedure) {
3538
3539                 assert (subject != null);
3540                 assert (relation != null);
3541                 assert (procedure != null);
3542
3543                 processor.forEachObject(this, subject, relation,
3544                                 new SingleOrErrorProcedure<Resource>(procedure));
3545
3546         }
3547
3548         @Override
3549         public void forSingleObject(Resource subject, Resource relation,
3550                         SyncProcedure<Resource> procedure) {
3551                 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3552                                 procedure));
3553         }
3554
3555         @Override
3556         public void forSingleObject(Resource subject, Resource relation,
3557                         Procedure<Resource> procedure) {
3558                 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3559                                 procedure));
3560         }
3561
3562         @Override
3563         public void forSingleStatement(Resource subject, Resource relation,
3564                         AsyncListener<Statement> listener) {
3565                 asyncRequest(new SingleStatement(subject, relation), listener);
3566         }
3567
3568         @Override
3569         public void forSingleStatement(Resource subject, Resource relation,
3570                         SyncListener<Statement> listener) {
3571                 asyncRequest(new SingleStatement(subject, relation), listener);
3572         }
3573
3574         @Override
3575         public void forSingleStatement(Resource subject, Resource relation,
3576                         Listener<Statement> listener) {
3577                 asyncRequest(new SingleStatement(subject, relation), listener);
3578         }
3579
3580         @Override
3581         final public void forSingleStatement(final Resource subject,
3582                         final Resource relation, final AsyncProcedure<Statement> procedure) {
3583
3584                 assert (subject != null);
3585                 assert (relation != null);
3586                 assert (procedure != null);
3587
3588                 processor.forEachStatement(this, subject, relation,
3589                                 new SingleOrErrorProcedure<Statement>(procedure));
3590
3591         }
3592
3593         @Override
3594         public void forSingleStatement(Resource subject, Resource relation,
3595                         SyncProcedure<Statement> procedure) {
3596                 forSingleStatement(subject, relation,
3597                                 new SyncToAsyncProcedure<Statement>(procedure));
3598         }
3599
3600         @Override
3601         public void forSingleStatement(Resource subject, Resource relation,
3602                         Procedure<Statement> procedure) {
3603                 forSingleStatement(subject, relation,
3604                                 new NoneToAsyncProcedure<Statement>(procedure));
3605         }
3606
3607         @Override
3608         public void forSingleType(Resource subject,
3609                         AsyncListener<Resource> listener) {
3610                 asyncRequest(new SingleTypeAny(subject), listener);
3611         }
3612
3613         @Override
3614         public void forSingleType(Resource subject,
3615                         SyncListener<Resource> listener) {
3616                 asyncRequest(new SingleTypeAny(subject), listener);
3617         }
3618
3619         @Override
3620         public void forSingleType(Resource subject,
3621                         Listener<Resource> listener) {
3622                 asyncRequest(new SingleTypeAny(subject), listener);
3623         }
3624
3625         @Override
3626         final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3627
3628                 assert (subject != null);
3629                 assert (procedure != null);
3630
3631                 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3632
3633                 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3634
3635                         @Override
3636                         public void execute(AsyncReadGraph graph, final Resource principalType) {
3637                                 checkedProcedure.offer(graph, principalType);
3638                         }
3639
3640                         @Override
3641                         public void finished(AsyncReadGraph graph) {
3642                                 checkedProcedure.dec(graph);
3643                         }
3644
3645                         @Override
3646                         public void exception(AsyncReadGraph graph, Throwable t) {
3647                                 checkedProcedure.exception(graph, t);
3648                         }
3649
3650                         @Override
3651                         public String toString() {
3652                                 return "forSingleType -> " + procedure;
3653                         }
3654
3655                 });
3656
3657         }
3658
3659         @Override
3660         public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3661                 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3662                                 procedure));
3663         }
3664
3665         @Override
3666         public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3667                 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3668                                 procedure));
3669         }
3670
3671         @Override
3672         public void forSingleType(Resource subject, Resource relation,
3673                         AsyncListener<Resource> listener) {
3674                 asyncRequest(new SingleType(subject, relation), listener);
3675         }
3676
3677         @Override
3678         public void forSingleType(Resource subject, Resource relation,
3679                         SyncListener<Resource> listener) {
3680                 asyncRequest(new SingleType(subject, relation), listener);
3681         }
3682
3683         @Override
3684         public void forSingleType(Resource subject, Resource relation,
3685                         Listener<Resource> listener) {
3686                 asyncRequest(new SingleType(subject, relation), listener);
3687         }
3688
3689         @Override
3690         final public void forSingleType(final Resource subject,
3691                         final Resource baseType, final AsyncProcedure<Resource> procedure) {
3692
3693                 assert (subject != null);
3694                 assert (procedure != null);
3695
3696                 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3697
3698                 processor.forEachPrincipalType(this, subject,
3699                                 new AsyncMultiProcedureAdapter<Resource>() {
3700
3701                                         @Override
3702                                         public void execute(AsyncReadGraph graph,
3703                                                         final Resource principalType) {
3704
3705                                                 checkedProcedure.inc();
3706
3707                                                 if(baseType == null) {
3708
3709                                                         checkedProcedure.offer(graph, principalType);
3710                                                         checkedProcedure.dec(graph);
3711
3712                                                 } else if(principalType.equals(baseType)) {
3713
3714                                                         checkedProcedure.offer(graph, principalType);
3715                                                         checkedProcedure.dec(graph);
3716
3717                                                 } else {
3718
3719                                                         processor.forSupertypes((ReadGraphImpl)graph, principalType,
3720                                                                         new AsyncProcedure<Set<Resource>>() {
3721
3722                                                                                 @Override
3723                                                                                 public void execute(
3724                                                                                                 AsyncReadGraph graph,
3725                                                                                                 Set<Resource> result) {
3726
3727                                                                                         if (result.contains(baseType))
3728                                                                                                 checkedProcedure.offer(graph,
3729                                                                                                                 principalType);
3730                                                                                         checkedProcedure.dec(graph);
3731
3732                                                                                 }
3733
3734                                                                                 @Override
3735                                                                                 public void exception(
3736                                                                                                 AsyncReadGraph graph,
3737                                                                                                 Throwable t) {
3738                                                                                         checkedProcedure
3739                                                                                                         .exception(graph, t);
3740                                                                                 }
3741
3742                                                                         });
3743
3744                                                 }
3745
3746                                         }
3747
3748                                         @Override
3749                                         public void finished(AsyncReadGraph graph) {
3750                                                 checkedProcedure.dec(graph);
3751                                         }
3752
3753                                         @Override
3754                                         public void exception(AsyncReadGraph graph, Throwable t) {
3755                                                 checkedProcedure.exception(graph, t);
3756                                         }
3757
3758                                         @Override
3759                                         public String toString() {
3760                                                 return "forSingleType -> " + procedure;
3761                                         }
3762
3763                                 });
3764
3765         }
3766
3767         @Override
3768         public void forSingleType(Resource subject, Resource relation,
3769                         SyncProcedure<Resource> procedure) {
3770                 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3771                                 procedure));
3772         }
3773
3774         @Override
3775         public void forSingleType(Resource subject, Resource relation,
3776                         Procedure<Resource> procedure) {
3777                 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3778                                 procedure));
3779         }
3780
3781         @Override
3782         public <T> void forValue(Resource subject, Binding binding,
3783                         AsyncListener<T> listener) {
3784                 asyncRequest(new Value<T>(subject, binding), listener);
3785         }
3786
3787         @Override
3788         public <T> void forValue(Resource subject, Binding binding,
3789                         SyncListener<T> listener) {
3790                 asyncRequest(new Value<T>(subject, binding), listener);
3791         }
3792
3793         @Override
3794         public <T> void forValue(Resource subject, Binding binding,
3795                         Listener<T> listener) {
3796                 asyncRequest(new Value<T>(subject, binding), listener);
3797         }
3798
3799         @Override
3800         public <T> void forValue(final Resource resource, final Binding binding,
3801                         final AsyncProcedure<T> procedure) {
3802
3803                 assert (resource != null);
3804                 assert (binding != null);
3805                 assert (procedure != null);
3806
3807                 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3808
3809                         @Override
3810                         public void execute(AsyncReadGraph graph, byte[] result) {
3811
3812                                 try {
3813
3814                                         if (result == null) {
3815                                                 procedure.exception(graph,
3816                                                                 new DoesNotContainValueException(
3817                                                                                 "No value for resource " + resource));
3818                                                 return;
3819                                         }
3820
3821                                         Serializer serializer = binding.serializer();
3822 //                                      Serializer serializer = Bindings.getSerializer( binding );
3823                                         Object obj = serializer.deserialize(result);
3824 //                                      if (!binding.isInstance(obj))
3825 //                                              procedure.exception(graph, new ClassCastException(
3826 //                                                              "Cannot get value " + obj + " with binding "
3827 //                                                                              + binding));
3828 //                                      else
3829                                                 procedure.execute(graph, (T) obj);
3830
3831                                 } catch (IOException e) {
3832                                         procedure.exception(graph, e);
3833                                 } catch (BufferUnderflowException e) {
3834                                         procedure.exception(graph, e);
3835                                 } catch (Throwable t) {
3836                                         procedure.exception(graph, t);
3837                                 }
3838
3839                         }
3840
3841                         @Override
3842                         public void exception(AsyncReadGraph graph, Throwable t) {
3843                                 try {
3844                                         procedure.exception(graph, t);
3845                                 } catch (Throwable t2) {
3846                                 Logger.defaultLogError(t2);
3847                                 }
3848                         }
3849
3850                         @Override
3851                         public String toString() {
3852                                 return "forValue -> " + procedure;
3853                         }
3854
3855                 });
3856
3857         }
3858
3859         @Override
3860         public <T> void forValue(Resource subject, Binding binding,
3861                         SyncProcedure<T> procedure) {
3862                 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3863         }
3864
3865         @Override
3866         public <T> void forValue(Resource subject, Binding binding,
3867                         Procedure<T> procedure) {
3868                 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3869         }
3870
3871         @Override
3872         public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3873                 asyncRequest(new ValueImplied<T>(subject), listener);
3874         }
3875
3876         @Override
3877         public <T> void forValue(Resource subject, SyncListener<T> listener) {
3878                 asyncRequest(new ValueImplied<T>(subject), listener);
3879         }
3880
3881         @Override
3882         public <T> void forValue(Resource subject, Listener<T> listener) {
3883                 asyncRequest(new ValueImplied<T>(subject), listener);
3884         }
3885
3886         @Override
3887         final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3888
3889                 assert (subject != null);
3890                 assert (procedure != null);
3891
3892                 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3893
3894                         @Override
3895                         public void execute(AsyncReadGraph graph, Datatype type) {
3896                                 // TODO: consider trying Bindings.getBeanBinding(type);
3897                                 Binding binding = Bindings.getBinding(type);
3898                                 graph.forValue(subject, binding, procedure);
3899                         }
3900
3901                         @Override
3902                         public void exception(AsyncReadGraph graph, Throwable throwable) {
3903                                 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3904                         }
3905
3906                 });
3907
3908         }
3909
3910         @Override
3911         public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3912                 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3913         }
3914
3915         @Override
3916         public <T> void forValue(Resource subject, Procedure<T> procedure) {
3917                 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3918         }
3919
3920         @Override
3921         public <T> void forRelatedValue(Resource subject, Resource relation,
3922                         AsyncListener<T> listener) {
3923                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3924         }
3925
3926         @Override
3927         public <T> void forRelatedValue(Resource subject, Resource relation,
3928                         SyncListener<T> listener) {
3929                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3930         }
3931
3932         @Override
3933         public <T> void forRelatedValue(Resource subject, Resource relation,
3934                         Listener<T> listener) {
3935                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3936         }
3937
3938         @Override
3939         final public <T> void forRelatedValue(final Resource subject,
3940                         final Resource relation, final AsyncProcedure<T> procedure) {
3941
3942                 assert (subject != null);
3943                 assert (relation != null);
3944                 assert (procedure != null);
3945
3946                 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3947
3948                 processor.forEachObject(this, subject, relation,
3949                                 new AsyncMultiProcedureAdapter<Resource>() {
3950
3951                                         @Override
3952                                         public void execute(AsyncReadGraph graph,
3953                                                         final Resource object) {
3954
3955                                                 checkedProcedure.inc();
3956
3957                                                 graph.forValue(object, new AsyncProcedure<Object>() {
3958
3959                                                         @Override
3960                                                         public void execute(AsyncReadGraph graph,
3961                                                                         Object result) {
3962                                                                 checkedProcedure.offer(graph, (T) result);
3963                                                                 checkedProcedure.dec(graph);
3964                                                         }
3965
3966                                                         @Override
3967                                                         public void exception(AsyncReadGraph graph,
3968                                                                         Throwable t) {
3969                                                                 checkedProcedure.exception(graph, t);
3970                                                         }
3971
3972                                                         @Override
3973                                                         public String toString() {
3974                                                                 return "forRelatedValue -> " + procedure;
3975                                                         }
3976
3977                                                 });
3978
3979                                         }
3980
3981                                         @Override
3982                                         public void finished(AsyncReadGraph graph) {
3983                                                 checkedProcedure.dec(graph);
3984                                         }
3985
3986                                         @Override
3987                                         public void exception(AsyncReadGraph graph, Throwable t) {
3988                                                 checkedProcedure.exception(graph, t);
3989                                         }
3990
3991                                 });
3992
3993         }
3994
3995         @Override
3996         public <T> void forRelatedValue(Resource subject, Resource relation,
3997                         SyncProcedure<T> procedure) {
3998                 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
3999                                 procedure));
4000         }
4001
4002         @Override
4003         public <T> void forRelatedValue(Resource subject, Resource relation,
4004                         Procedure<T> procedure) {
4005                 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4006                                 procedure));
4007         }
4008
4009         @Override
4010         public <T> void forRelatedValue(Resource subject, Resource relation,
4011                         Binding binding, AsyncListener<T> listener) {
4012                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4013         }
4014
4015         @Override
4016         public <T> void forRelatedValue(Resource subject, Resource relation,
4017                         Binding binding, SyncListener<T> listener) {
4018                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4019         }
4020
4021         @Override
4022         public <T> void forRelatedValue(Resource subject, Resource relation,
4023                         Binding binding, Listener<T> listener) {
4024                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
4025         }
4026
4027         @Override
4028         final public <T> void forRelatedValue(final Resource subject,
4029                         final Resource relation, final Binding binding,
4030                         final AsyncProcedure<T> procedure) {
4031
4032                 assert (subject != null);
4033                 assert (relation != null);
4034                 assert (binding != null);
4035                 assert (procedure != null);
4036
4037                 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
4038
4039                 processor.forEachObject(this, subject, relation,
4040                                 new AsyncMultiProcedureAdapter<Resource>() {
4041
4042                                         @Override
4043                                         public void execute(AsyncReadGraph graph,
4044                                                         final Resource object) {
4045
4046                                                 checkedProcedure.inc();
4047
4048                                                 graph.forValue(object, binding, new AsyncProcedure<Object>() {
4049
4050                                                                         @Override
4051                                                                         public void execute(AsyncReadGraph graph,
4052                                                                                         Object result) {
4053
4054                                                                                 checkedProcedure.offer(graph,
4055                                                                                                 (T) result);
4056                                                                                 checkedProcedure.dec(graph);
4057                                                                         }
4058
4059                                                                         @Override
4060                                                                         public void exception(AsyncReadGraph graph,
4061                                                                                         Throwable t) {
4062                                                                                 checkedProcedure.exception(graph, t);
4063                                                                         }
4064
4065                                                                         @Override
4066                                                                         public String toString() {
4067                                                                                 return "forRelatedValue -> "
4068                                                                                                 + procedure;
4069                                                                         }
4070
4071                                                                 });
4072
4073                                         }
4074
4075                                         @Override
4076                                         public void finished(AsyncReadGraph graph) {
4077                                                 checkedProcedure.dec(graph);
4078                                         }
4079
4080                                         @Override
4081                                         public void exception(AsyncReadGraph graph, Throwable t) {
4082                                                 checkedProcedure.exception(graph, t);
4083                                         }
4084
4085                                 });
4086
4087         }
4088
4089         @Override
4090         public <T> void forRelatedValue(Resource subject, Resource relation,
4091                         Binding binding, SyncProcedure<T> procedure) {
4092                 forRelatedValue(subject, relation, binding,
4093                                 new SyncToAsyncProcedure<T>(procedure));
4094         }
4095
4096         @Override
4097         public <T> void forRelatedValue(Resource subject, Resource relation,
4098                         Binding binding, Procedure<T> procedure) {
4099                 forRelatedValue(subject, relation, binding,
4100                                 new NoneToAsyncProcedure<T>(procedure));
4101         }
4102
4103         @Override
4104         public <T> void forAdapted(Resource resource, Class<T> clazz,
4105                         AsyncListener<T> listener) {
4106                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4107         }
4108
4109         @Override
4110         public <T> void forAdapted(Resource resource, Class<T> clazz,
4111                         SyncListener<T> listener) {
4112                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4113         }
4114
4115         @Override
4116         public <T> void forAdapted(Resource resource, Class<T> clazz,
4117                         Listener<T> listener) {
4118                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4119         }
4120
4121         @Override
4122         final public <T> void forAdapted(final Resource resource,
4123                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
4124
4125                 assert (resource != null);
4126                 assert (clazz != null);
4127                 assert (procedure != null);
4128
4129                 final AdaptionService service = getSession().peekService(AdaptionService.class);
4130                 if (service == null)
4131                         procedure.exception(this, new ServiceException("No AdaptionService available"));
4132                 else
4133                         service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4134
4135         }
4136
4137         @Override
4138         public <T> void forAdapted(Resource resource, Class<T> clazz,
4139                         SyncProcedure<T> procedure) {
4140                 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4141         }
4142
4143         @Override
4144         public <T> void forAdapted(Resource resource, Class<T> clazz,
4145                         Procedure<T> procedure) {
4146                 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4147         }
4148
4149         @Override
4150         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4151                         AsyncListener<T> listener) {
4152                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4153         }
4154
4155         @Override
4156         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4157                         SyncListener<T> listener) {
4158                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4159         }
4160
4161         @Override
4162         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4163                         Listener<T> listener) {
4164                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4165         }
4166
4167         @Override
4168         final public <T> void forUniqueAdapted(final Resource resource,
4169                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
4170
4171                 assert (resource != null);
4172                 assert (clazz != null);
4173                 assert (procedure != null);
4174
4175                 final AdaptionService service = getSession().peekService(AdaptionService.class);
4176                 if (service == null)
4177                         procedure.exception(this, new ServiceException("No AdaptionService available"));
4178                 else
4179                         service.adaptNew(this, resource, clazz, false, procedure);
4180
4181         }
4182
4183         @Override
4184         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4185                         SyncProcedure<T> procedure) {
4186                 forUniqueAdapted(resource, clazz,
4187                                 new SyncToAsyncProcedure<T>(procedure));
4188         }
4189
4190         @Override
4191         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4192                         Procedure<T> procedure) {
4193                 forUniqueAdapted(resource, clazz,
4194                                 new NoneToAsyncProcedure<T>(procedure));
4195         }
4196
4197         @Override
4198         public void forPossibleInverse(Resource subject,
4199                         AsyncListener<Resource> listener) {
4200                 asyncRequest(new PossibleInverse(subject), listener);
4201         }
4202
4203         @Override
4204         public void forPossibleInverse(Resource subject,
4205                         SyncListener<Resource> listener) {
4206                 asyncRequest(new PossibleInverse(subject), listener);
4207         }
4208
4209         @Override
4210         public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4211                 asyncRequest(new PossibleInverse(subject), listener);
4212         }
4213
4214         @Override
4215         final public void forPossibleInverse(final Resource relation,
4216                         final AsyncProcedure<Resource> procedure) {
4217
4218                 assert (relation != null);
4219                 assert (procedure != null);
4220
4221                 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4222
4223         }
4224
4225         @Override
4226         public void forPossibleInverse(Resource subject,
4227                         SyncProcedure<Resource> procedure) {
4228                 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4229                                 procedure));
4230         }
4231
4232         @Override
4233         public void forPossibleInverse(Resource subject,
4234                         Procedure<Resource> procedure) {
4235                 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4236                                 procedure));
4237         }
4238
4239         @Override
4240         public void forPossibleObject(Resource subject, Resource relation,
4241                         AsyncListener<Resource> listener) {
4242                 asyncRequest(new PossibleObject(subject, relation), listener);
4243         }
4244
4245         @Override
4246         public void forPossibleObject(Resource subject, Resource relation,
4247                         SyncListener<Resource> listener) {
4248                 asyncRequest(new PossibleObject(subject, relation), listener);
4249         }
4250
4251         @Override
4252         public void forPossibleObject(Resource subject, Resource relation,
4253                         Listener<Resource> listener) {
4254                 asyncRequest(new PossibleObject(subject, relation), listener);
4255         }
4256
4257         @Override
4258         final public void forPossibleObject(final Resource subject,
4259                         final Resource relation, final AsyncProcedure<Resource> procedure) {
4260
4261                 assert (subject != null);
4262                 assert (relation != null);
4263                 assert (procedure != null);
4264
4265                 processor.forEachObject(this, subject, relation,
4266                                 new SingleOrNullProcedure<Resource>(procedure));
4267
4268         }
4269
4270         @Override
4271         public void forPossibleObject(Resource subject, Resource relation,
4272                         SyncProcedure<Resource> procedure) {
4273                 forPossibleObject(subject, relation,
4274                                 new SyncToAsyncProcedure<Resource>(procedure));
4275         }
4276
4277         @Override
4278         public void forPossibleObject(Resource subject, Resource relation,
4279                         Procedure<Resource> procedure) {
4280                 forPossibleObject(subject, relation,
4281                                 new NoneToAsyncProcedure<Resource>(procedure));
4282         }
4283
4284         @Override
4285         public void forPossibleStatement(Resource subject, Resource relation,
4286                         AsyncListener<Statement> listener) {
4287                 asyncRequest(new PossibleStatement(subject, relation), listener);
4288         }
4289
4290         @Override
4291         public void forPossibleStatement(Resource subject, Resource relation,
4292                         SyncListener<Statement> listener) {
4293                 asyncRequest(new PossibleStatement(subject, relation), listener);
4294         }
4295
4296         @Override
4297         public void forPossibleStatement(Resource subject, Resource relation,
4298                         Listener<Statement> listener) {
4299                 asyncRequest(new PossibleStatement(subject, relation), listener);
4300         }
4301
4302         @Override
4303         final public void forPossibleStatement(final Resource subject,
4304                         final Resource relation, final AsyncProcedure<Statement> procedure) {
4305
4306                 assert (subject != null);
4307                 assert (relation != null);
4308                 assert (procedure != null);
4309
4310                 processor.forEachStatement(this, subject, relation,
4311                                 new SingleFunctionalOrNullProcedure<Statement>(
4312                                                 "forPossibleStatement", procedure));
4313
4314         }
4315
4316         @Override
4317         public void forPossibleStatement(Resource subject, Resource relation,
4318                         SyncProcedure<Statement> procedure) {
4319                 forPossibleStatement(subject, relation,
4320                                 new SyncToAsyncProcedure<Statement>(procedure));
4321         }
4322
4323         @Override
4324         public void forPossibleStatement(Resource subject, Resource relation,
4325                         Procedure<Statement> procedure) {
4326                 forPossibleStatement(subject, relation,
4327                                 new NoneToAsyncProcedure<Statement>(procedure));
4328         }
4329
4330         @Override
4331         public void forPossibleType(Resource subject, Resource relation,
4332                         AsyncListener<Resource> listener) {
4333                 asyncRequest(new PossibleType(subject, relation), listener);
4334         }
4335
4336         @Override
4337         public void forPossibleType(Resource subject, Resource relation,
4338                         SyncListener<Resource> listener) {
4339                 asyncRequest(new PossibleType(subject, relation), listener);
4340         }
4341
4342         @Override
4343         public void forPossibleType(Resource subject, Resource relation,
4344                         Listener<Resource> listener) {
4345                 asyncRequest(new PossibleType(subject, relation), listener);
4346         }
4347
4348         @Override
4349         final public void forPossibleType(final Resource subject,
4350                         final Resource baseType, final AsyncProcedure<Resource> procedure) {
4351
4352                 assert (subject != null);
4353                 assert (procedure != null);
4354
4355                 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4356
4357                 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4358
4359                                         @Override
4360                                         public void execute(AsyncReadGraph graph,
4361                                                         final Resource principalType) {
4362
4363                                                 if (baseType == null) {
4364
4365                                                         checkedProcedure.offer(graph, principalType);
4366
4367                                                 } else if (principalType.equals(baseType)) {
4368
4369                                                         checkedProcedure.offer(graph, principalType);
4370
4371                                                 } else {
4372
4373                                                         checkedProcedure.inc();
4374
4375                                                         processor.forSupertypes((ReadGraphImpl)graph, principalType,
4376                                                                         new AsyncProcedure<Set<Resource>>() {
4377
4378                                                                                 @Override
4379                                                                                 public void execute(
4380                                                                                                 AsyncReadGraph graph,
4381                                                                                                 Set<Resource> result) {
4382
4383                                                                                         if (result.contains(baseType)) {
4384                                                                                                 checkedProcedure.offer(graph,
4385                                                                                                                 principalType);
4386                                                                                         }
4387
4388                                                                                         checkedProcedure.dec(graph);
4389
4390                                                                                 }
4391
4392                                                                                 @Override
4393                                                                                 public void exception(
4394                                                                                                 AsyncReadGraph graph,
4395                                                                                                 Throwable t) {
4396                                                                                         checkedProcedure.exception(graph, t);
4397                                                                                         checkedProcedure.dec(graph);
4398                                                                                 }
4399
4400                                                                                 @Override
4401                                                                                 public String toString() {
4402                                                                                         return "forPossibleType -> "
4403                                                                                                         + procedure;
4404                                                                                 }
4405
4406                                                                         });
4407
4408                                                 }
4409
4410                                         }
4411
4412                                         @Override
4413                                         public void finished(AsyncReadGraph graph) {
4414                                                 checkedProcedure.dec(graph);
4415                                         }
4416
4417                                         @Override
4418                                         public void exception(AsyncReadGraph graph, Throwable t) {
4419                                                 checkedProcedure.exception(graph, t);
4420                                                 checkedProcedure.dec(graph);
4421                                         }
4422
4423                                 });
4424
4425         }
4426
4427         @Override
4428         public void forPossibleType(Resource subject, Resource relation,
4429                         SyncProcedure<Resource> procedure) {
4430                 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4431                                 procedure));
4432         }
4433
4434         @Override
4435         public void forPossibleType(Resource subject, Resource relation,
4436                         Procedure<Resource> procedure) {
4437                 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4438                                 procedure));
4439         }
4440
4441         @Override
4442         public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4443                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4444         }
4445
4446         @Override
4447         public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4448                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4449         }
4450
4451         @Override
4452         public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4453                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4454         }
4455
4456         @Override
4457         final public <T> void forPossibleValue(final Resource subject,
4458                         final AsyncProcedure<T> procedure) {
4459
4460                 assert (subject != null);
4461                 assert (procedure != null);
4462
4463                 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4464
4465                         @Override
4466                         public void execute(AsyncReadGraph graph, final Datatype type) {
4467                                 if (type == null) {
4468                                         procedure.execute(graph, null);
4469                                 } else {
4470                                         try {
4471                                                 // TODO: consider trying Bindings.getBeanBinding(type);
4472                                                 Binding binding = Bindings.getBinding(type);
4473                                                 graph.forPossibleValue(subject, binding, procedure);
4474                                         } catch (RuntimeBindingConstructionException e) {
4475                                                 procedure.exception(graph, e);
4476                                         }
4477                                 }
4478                         }
4479
4480                         @Override
4481                         public void exception(AsyncReadGraph graph, Throwable t) {
4482                                 procedure.exception(graph, t);
4483                         }
4484
4485                         @Override
4486                         public String toString() {
4487                                 return "forPossibleValue -> " + procedure;
4488                         }
4489
4490                 });
4491
4492         }
4493
4494         @Override
4495         public <T> void forPossibleValue(Resource subject,
4496                         SyncProcedure<T> procedure) {
4497                 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4498         }
4499
4500         @Override
4501         public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4502                 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4503         }
4504
4505         @Override
4506         public <T> void forPossibleValue(Resource subject, Binding binding,
4507                         AsyncListener<T> listener) {
4508                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4509         }
4510
4511         @Override
4512         public <T> void forPossibleValue(Resource subject, Binding binding,
4513                         SyncListener<T> listener) {
4514                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4515         }
4516
4517         @Override
4518         public <T> void forPossibleValue(Resource subject, Binding binding,
4519                         Listener<T> listener) {
4520                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4521         }
4522
4523         @Override
4524         final public <T> void forPossibleValue(final Resource resource,
4525                         final Binding binding, final AsyncProcedure<T> procedure) {
4526
4527                 assert (resource != null);
4528                 assert (binding != null);
4529                 assert (procedure != null);
4530
4531                 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4532
4533                         @Override
4534                         public void execute(AsyncReadGraph graph, byte[] result) {
4535
4536                                 try {
4537
4538                                         if (result == null) {
4539                                                 procedure.execute(graph, null);
4540                                                 return;
4541                                         }
4542
4543                                         Serializer serializer = Bindings.getSerializer( binding );
4544                                         Object obj = serializer.deserialize(result);
4545                                         if (!binding.isInstance(obj))
4546                                                 procedure.exception(graph, new ClassCastException(
4547                                                                 "Cannot get value " + obj + " with binding "
4548                                                                                 + binding));
4549                                         else
4550                                                 procedure.execute(graph, (T) obj);
4551
4552                                 } catch (IOException e) {
4553                                         procedure.exception(graph, e);
4554                                 } catch (BufferUnderflowException e) {
4555                                         procedure.exception(graph, e);
4556                                 } catch (Throwable t) {
4557                                         procedure.exception(graph, t);
4558                                 }
4559
4560                         }
4561
4562                         @Override
4563                         public void exception(AsyncReadGraph graph, Throwable t) {
4564                                 try {
4565                                         procedure.exception(graph, t);
4566                                 } catch (Throwable t2) {
4567                                 Logger.defaultLogError(t2);
4568                                 }
4569                         }
4570
4571                         @Override
4572                         public String toString() {
4573                                 return "forPossibleValue -> " + procedure;
4574                         }
4575
4576                 });
4577
4578         }
4579
4580         @Override
4581         public <T> void forPossibleValue(Resource subject, Binding binding,
4582                         SyncProcedure<T> procedure) {
4583                 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4584                                 procedure));
4585         }
4586
4587         @Override
4588         public <T> void forPossibleValue(Resource subject, Binding binding,
4589                         Procedure<T> procedure) {
4590                 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4591                                 procedure));
4592         }
4593
4594         @Override
4595         public <T> void forPossibleRelatedValue(Resource subject,
4596                         Resource relation, AsyncListener<T> listener) {
4597                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4598                                 listener);
4599         }
4600
4601         @Override
4602         public <T> void forPossibleRelatedValue(Resource subject,
4603                         Resource relation, SyncListener<T> listener) {
4604                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4605                                 listener);
4606         }
4607
4608         @Override
4609         public <T> void forPossibleRelatedValue(Resource subject,
4610                         Resource relation, Listener<T> listener) {
4611                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4612                                 listener);
4613         }
4614
4615         @Override
4616         final public <T> void forPossibleRelatedValue(final Resource subject,
4617                         final Resource relation, final AsyncProcedure<T> procedure) {
4618
4619                 assert (subject != null);
4620                 assert (relation != null);
4621                 assert (procedure != null);
4622
4623                 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4624
4625                 processor.forEachObject(this, subject, relation,
4626                                 new AsyncMultiProcedureAdapter<Resource>() {
4627
4628                                         @Override
4629                                         public void execute(AsyncReadGraph graph,
4630                                                         final Resource object) {
4631
4632                                                 checkedProcedure.inc();
4633
4634                                                 graph.forValue(object, new AsyncProcedure<Object>() {
4635
4636                                                         @Override
4637                                                         public void execute(AsyncReadGraph graph,
4638                                                                         Object result) {
4639                                                                 checkedProcedure.offer(graph, (T) result);
4640                                                                 checkedProcedure.dec(graph);
4641                                                         }
4642
4643                                                         @Override
4644                                                         public void exception(AsyncReadGraph graph,
4645                                                                         Throwable t) {
4646                                                                 checkedProcedure.exception(graph, t);
4647                                                                 checkedProcedure.dec(graph);
4648                                                         }
4649
4650                                                 });
4651
4652                                         }
4653
4654                                         @Override
4655                                         public void finished(AsyncReadGraph graph) {
4656
4657                                                 checkedProcedure.dec(graph);
4658                                         }
4659
4660                                         @Override
4661                                         public void exception(AsyncReadGraph graph, Throwable t) {
4662                                                 checkedProcedure.exception(graph, t);
4663                                                 checkedProcedure.dec(graph);
4664                                         }
4665
4666                                         @Override
4667                                         public String toString() {
4668                                                 return "forPossibleRelatedValue -> " + procedure;
4669                                         }
4670                                 });
4671
4672         }
4673
4674         @Override
4675         public <T> void forPossibleRelatedValue(Resource subject,
4676                         Resource relation, SyncProcedure<T> procedure) {
4677                 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4678                                 procedure));
4679         }
4680
4681         @Override
4682         public <T> void forPossibleRelatedValue(Resource subject,
4683                         Resource relation, Procedure<T> procedure) {
4684                 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4685                                 procedure));
4686         }
4687
4688         @Override
4689         public <T> void forPossibleRelatedValue(Resource subject,
4690                         Resource relation, Binding binding, AsyncListener<T> listener) {
4691                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4692                                 listener);
4693         }
4694
4695         @Override
4696         public <T> void forPossibleRelatedValue(Resource subject,
4697                         Resource relation, Binding binding, SyncListener<T> listener) {
4698                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4699                                 listener);
4700         }
4701
4702         @Override
4703         public <T> void forPossibleRelatedValue(Resource subject,
4704                         Resource relation, Binding binding, Listener<T> listener) {
4705                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4706                                 listener);
4707         }
4708
4709 //      @Override
4710 //      final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4711 //                      final AsyncProcedure<T> procedure) {
4712 //
4713 //              forPossibleRelatedValue(subject, relation, binding, procedure, false);
4714 //
4715 //      }
4716
4717         final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4718                         final AsyncProcedure<T> procedure) {
4719
4720                 assert (subject != null);
4721                 assert (relation != null);
4722                 assert (procedure != null);
4723
4724                 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4725
4726                         @Override
4727                         public void execute(AsyncReadGraph graph, Resource object) {
4728
4729                                 if(object == null) {
4730                                         procedure.execute(graph, null);
4731                                         return;
4732                                 }
4733
4734                                 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4735
4736                                         @Override
4737                                         public void execute(AsyncReadGraph graph, byte[] bytes) {
4738
4739                                                 if(bytes != null) {
4740
4741                                                         try {
4742
4743                                                                 Serializer serializer = binding.serializer();
4744                                                                 Object obj = serializer.deserialize(bytes);
4745                                                                 if (!binding.isInstance(obj)) {
4746                                                                         procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4747                                                                 } else {
4748                                                                         procedure.execute(graph, (T) obj);
4749                                                                 }
4750
4751                                                         } catch (Throwable t) {
4752
4753                                                                 procedure.exception(graph, t);
4754
4755                                                         }
4756
4757                                                 } else {
4758
4759                                                         procedure.execute(graph, null);
4760
4761                                                 }
4762
4763                                         }
4764
4765                                         @Override
4766                                         public void exception(AsyncReadGraph graph, Throwable t) {
4767                                                 procedure.exception(graph, t);
4768                                         }
4769
4770                                 });
4771
4772                         }
4773
4774                         @Override
4775                         public void exception(AsyncReadGraph graph, Throwable throwable) {
4776                                 throwable.printStackTrace();
4777                                 procedure.exception(graph, throwable);
4778                         }
4779
4780                 });
4781
4782         }
4783
4784         @Override
4785         public <T> void forPossibleRelatedValue(Resource subject,
4786                         Resource relation, Binding binding, SyncProcedure<T> procedure) {
4787                 forPossibleRelatedValue(subject, relation, binding,
4788                                 new SyncToAsyncProcedure<T>(procedure));
4789         }
4790
4791         @Override
4792         public <T> void forPossibleRelatedValue(Resource subject,
4793                         Resource relation, Binding binding, Procedure<T> procedure) {
4794                 forPossibleRelatedValue(subject, relation, binding,
4795                                 new NoneToAsyncProcedure<T>(procedure));
4796         }
4797
4798         @Override
4799         public void forIsInstanceOf(Resource subject, Resource relation,
4800                         AsyncListener<Boolean> listener) {
4801                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4802         }
4803
4804         @Override
4805         public void forIsInstanceOf(Resource subject, Resource relation,
4806                         SyncListener<Boolean> listener) {
4807                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4808         }
4809
4810         @Override
4811         public void forIsInstanceOf(Resource subject, Resource relation,
4812                         Listener<Boolean> listener) {
4813                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4814         }
4815
4816         @Override
4817         final public void forIsInstanceOf(final Resource resource,
4818                         final Resource type, final AsyncProcedure<Boolean> procedure) {
4819
4820                 assert (resource != null);
4821                 assert (type != null);
4822                 assert (procedure != null);
4823
4824                 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4825
4826                         @Override
4827                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4828
4829                                 try {
4830                                         if (result.contains(type))
4831                                                 procedure.execute(graph, true);
4832                                         else
4833                                                 procedure.execute(graph, false);
4834                                 } catch (Throwable t) {
4835                                 Logger.defaultLogError(t);
4836                                 }
4837                         }
4838
4839                         @Override
4840                         public void exception(AsyncReadGraph graph, Throwable t) {
4841                                 try {
4842                                         procedure.exception(graph, t);
4843                                 } catch (Throwable t2) {
4844                                 Logger.defaultLogError(t2);
4845                                 }
4846                         }
4847
4848                         @Override
4849                         public String toString() {
4850                                 return "forIsInstanceOf -> " + procedure;
4851                         }
4852
4853                 });
4854
4855         }
4856
4857         @Override
4858         public void forIsInstanceOf(Resource subject, Resource relation,
4859                         SyncProcedure<Boolean> procedure) {
4860                 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4861                                 procedure));
4862         }
4863
4864         @Override
4865         public void forIsInstanceOf(Resource subject, Resource relation,
4866                         Procedure<Boolean> procedure) {
4867                 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4868                                 procedure));
4869         }
4870
4871         @Override
4872         public void forIsInheritedFrom(Resource subject, Resource relation,
4873                         AsyncListener<Boolean> listener) {
4874                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4875         }
4876
4877         @Override
4878         public void forIsInheritedFrom(Resource subject, Resource relation,
4879                         SyncListener<Boolean> listener) {
4880                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4881         }
4882
4883         @Override
4884         public void forIsInheritedFrom(Resource subject, Resource relation,
4885                         Listener<Boolean> listener) {
4886                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4887         }
4888
4889         @Override
4890         final public void forIsInheritedFrom(final Resource resource,
4891                         final Resource type, final AsyncProcedure<Boolean> procedure) {
4892
4893                 assert (resource != null);
4894                 assert (type != null);
4895                 assert (procedure != null);
4896
4897                 if (resource.equals(type)) {
4898                         try {
4899                                 procedure.execute(this, true);
4900                         } catch (Throwable t) {
4901                         Logger.defaultLogError(t);
4902                         }
4903                         return;
4904                 }
4905
4906                 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4907
4908                         @Override
4909                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4910                                 try {
4911                                         if (result.contains(type))
4912                                                 procedure.execute(graph, true);
4913                                         else
4914                                                 procedure.execute(graph, false);
4915                                 } catch (Throwable t) {
4916                                 Logger.defaultLogError(t);
4917                                 }
4918                         }
4919
4920                         @Override
4921                         public void exception(AsyncReadGraph graph, Throwable t) {
4922                                 try {
4923                                         procedure.exception(graph, t);
4924                                 } catch (Throwable t2) {
4925                                 Logger.defaultLogError(t2);
4926                                 }
4927                         }
4928
4929                         @Override
4930                         public String toString() {
4931                                 return "forIsInheritedFrom -> " + procedure;
4932                         }
4933
4934                 });
4935
4936         }
4937
4938         @Override
4939         public void forIsInheritedFrom(Resource subject, Resource relation,
4940                         SyncProcedure<Boolean> procedure) {
4941                 forIsInheritedFrom(subject, relation,
4942                                 new SyncToAsyncProcedure<Boolean>(procedure));
4943         }
4944
4945         @Override
4946         public void forIsInheritedFrom(Resource subject, Resource relation,
4947                         Procedure<Boolean> procedure) {
4948                 forIsInheritedFrom(subject, relation,
4949                                 new NoneToAsyncProcedure<Boolean>(procedure));
4950         }
4951
4952         @Override
4953         public void forIsSubrelationOf(Resource subject, Resource relation,
4954                         AsyncListener<Boolean> listener) {
4955                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4956         }
4957
4958         @Override
4959         public void forIsSubrelationOf(Resource subject, Resource relation,
4960                         SyncListener<Boolean> listener) {
4961                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4962         }
4963
4964         @Override
4965         public void forIsSubrelationOf(Resource subject, Resource relation,
4966                         Listener<Boolean> listener) {
4967                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4968         }
4969
4970         @Override
4971         final public void forIsSubrelationOf(final Resource resource,
4972                         final Resource relation, final AsyncProcedure<Boolean> procedure) {
4973
4974                 assert (resource != null);
4975                 assert (relation != null);
4976                 assert (procedure != null);
4977
4978                 if (resource.equals(relation)) {
4979                         procedure.execute(this, true);
4980                         return;
4981                 }
4982
4983                 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4984
4985                         @Override
4986                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4987                                 try {
4988                                         if (result.contains(relation))
4989                                                 procedure.execute(graph, true);
4990                                         else
4991                                                 procedure.execute(graph, false);
4992                                 } catch (Throwable t) {
4993                                 Logger.defaultLogError(t);
4994                                 }
4995                         }
4996
4997                         @Override
4998                         public void exception(AsyncReadGraph graph, Throwable t) {
4999                                 try {
5000                                         procedure.exception(graph, t);
5001                                 } catch (Throwable t2) {
5002                                 Logger.defaultLogError(t2);
5003                                 }
5004                         }
5005
5006                         @Override
5007                         public String toString() {
5008                                 return "forIsSubrelationOf -> " + procedure;
5009                         }
5010
5011                 });
5012
5013         }
5014
5015         @Override
5016         public void forIsSubrelationOf(Resource subject, Resource relation,
5017                         SyncProcedure<Boolean> procedure) {
5018                 forIsSubrelationOf(subject, relation,
5019                                 new SyncToAsyncProcedure<Boolean>(procedure));
5020         }
5021
5022         @Override
5023         public void forIsSubrelationOf(Resource subject, Resource relation,
5024                         Procedure<Boolean> procedure) {
5025                 forIsSubrelationOf(subject, relation,
5026                                 new NoneToAsyncProcedure<Boolean>(procedure));
5027         }
5028
5029         @Override
5030         public void forHasStatement(Resource subject,
5031                         AsyncListener<Boolean> listener) {
5032                 asyncRequest(new HasStatementSubject(subject), listener);
5033         }
5034
5035         @Override
5036         public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
5037                 asyncRequest(new HasStatementSubject(subject), listener);
5038         }
5039
5040         @Override
5041         public void forHasStatement(Resource subject, Listener<Boolean> listener) {
5042                 asyncRequest(new HasStatementSubject(subject), listener);
5043         }
5044
5045         @Override
5046         final public void forHasStatement(final Resource subject,
5047                         final AsyncProcedure<Boolean> procedure) {
5048
5049                 assert (subject != null);
5050                 assert (procedure != null);
5051
5052                 processor.forHasStatement(this, subject, procedure);
5053
5054         }
5055
5056         @Override
5057         public void forHasStatement(Resource subject,
5058                         SyncProcedure<Boolean> procedure) {
5059                 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5060         }
5061
5062         @Override
5063         public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
5064                 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5065         }
5066
5067         @Override
5068         public void forHasStatement(Resource subject, Resource relation,
5069                         AsyncListener<Boolean> listener) {
5070                 asyncRequest(new HasStatement(subject, relation), listener);
5071         }
5072
5073         @Override
5074         public void forHasStatement(Resource subject, Resource relation,
5075                         SyncListener<Boolean> listener) {
5076                 asyncRequest(new HasStatement(subject, relation), listener);
5077         }
5078
5079         @Override
5080         public void forHasStatement(Resource subject, Resource relation,
5081                         Listener<Boolean> listener) {
5082                 asyncRequest(new HasStatement(subject, relation), listener);
5083         }
5084
5085         @Override
5086         final public void forHasStatement(final Resource subject,
5087                         final Resource relation, final AsyncProcedure<Boolean> procedure) {
5088
5089                 assert (subject != null);
5090                 assert (relation != null);
5091                 assert (procedure != null);
5092
5093                 processor.forHasStatement(this, subject, relation, procedure);
5094
5095         }
5096
5097         @Override
5098         public void forHasStatement(Resource subject, Resource relation,
5099                         SyncProcedure<Boolean> procedure) {
5100                 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5101                                 procedure));
5102         }
5103
5104         @Override
5105         public void forHasStatement(Resource subject, Resource relation,
5106                         Procedure<Boolean> procedure) {
5107                 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5108                                 procedure));
5109         }
5110
5111         @Override
5112         public void forHasStatement(Resource subject, Resource relation,
5113                         Resource object, AsyncListener<Boolean> listener) {
5114                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5115                                 listener);
5116         }
5117
5118         @Override
5119         public void forHasStatement(Resource subject, Resource relation,
5120                         Resource object, SyncListener<Boolean> listener) {
5121                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5122                                 listener);
5123         }
5124
5125         @Override
5126         public void forHasStatement(Resource subject, Resource relation,
5127                         Resource object, Listener<Boolean> listener) {
5128                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5129                                 listener);
5130         }
5131
5132         @Override
5133         final public void forHasStatement(final Resource subject,
5134                         final Resource relation, final Resource object,
5135                         final AsyncProcedure<Boolean> procedure) {
5136
5137                 assert (subject != null);
5138                 assert (relation != null);
5139                 assert (object != null);
5140                 assert (procedure != null);
5141
5142                 processor.forHasStatement(this, subject, relation, object, procedure);
5143
5144         }
5145
5146         @Override
5147         public void forHasStatement(Resource subject, Resource relation,
5148                         Resource object, SyncProcedure<Boolean> procedure) {
5149                 forHasStatement(subject, relation, object,
5150                                 new SyncToAsyncProcedure<Boolean>(procedure));
5151         }
5152
5153         @Override
5154         public void forHasStatement(Resource subject, Resource relation,
5155                         Resource object, Procedure<Boolean> procedure) {
5156                 forHasStatement(subject, relation, object,
5157                                 new NoneToAsyncProcedure<Boolean>(procedure));
5158         }
5159
5160         @Override
5161         public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5162                 asyncRequest(new HasValue(subject), listener);
5163         }
5164
5165         @Override
5166         public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5167                 asyncRequest(new HasValue(subject), listener);
5168         }
5169
5170         @Override
5171         public void forHasValue(Resource subject, Listener<Boolean> listener) {
5172                 asyncRequest(new HasValue(subject), listener);
5173         }
5174
5175         @Override
5176         final public void forHasValue(final Resource subject,
5177                         final AsyncProcedure<Boolean> procedure) {
5178
5179                 assert (subject != null);
5180                 assert (procedure != null);
5181
5182                 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5183
5184                         @Override
5185                         public void execute(AsyncReadGraph graph, byte[] result) {
5186                                 try {
5187                                         if (result == null)
5188                                                 procedure.execute(graph, false);
5189                                         else
5190                                                 procedure.execute(graph, true);
5191                                 } catch (Throwable t) {
5192                                 Logger.defaultLogError(t);
5193                                 }
5194                         }
5195
5196                         @Override
5197                         public void exception(AsyncReadGraph graph, Throwable t) {
5198                                 try {
5199                                         procedure.exception(graph, t);
5200                                 } catch (Throwable t2) {
5201                                 Logger.defaultLogError(t2);
5202                                 }
5203                         }
5204
5205                         @Override
5206                         public String toString() {
5207                                 return "forHasValue -> " + procedure;
5208                         }
5209
5210                 });
5211
5212         }
5213
5214         @Override
5215         public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5216                 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5217         }
5218
5219         @Override
5220         public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5221                 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5222         }
5223
5224         @Override
5225         public void forOrderedSet(Resource subject,
5226                         AsyncMultiListener<Resource> listener) {
5227                 asyncRequest(new OrderedSet(subject), listener);
5228         }
5229
5230         @Override
5231         public void forOrderedSet(Resource subject,
5232                         SyncMultiListener<Resource> listener) {
5233                 asyncRequest(new OrderedSet(subject), listener);
5234         }
5235
5236         @Override
5237         public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5238                 asyncRequest(new OrderedSet(subject), listener);
5239         }
5240
5241         @Override
5242         final public void forOrderedSet(final Resource subject,
5243                         final AsyncMultiProcedure<Resource> procedure) {
5244
5245                 assert (subject != null);
5246                 assert (procedure != null);
5247
5248                 processor.forOrderedSet(this, subject,
5249                                 new AsyncMultiProcedure<Resource>() {
5250
5251                                         @Override
5252                                         public void finished(AsyncReadGraph graph) {
5253                                                 try {
5254                                                         procedure.finished(graph);
5255                                                 } catch (Throwable t) {
5256                                                 Logger.defaultLogError(t);
5257                                                 }
5258                                         }
5259
5260                                         @Override
5261                                         public void execute(AsyncReadGraph graph, Resource result) {
5262                                                 try {
5263                                                         procedure.execute(graph, result);
5264                                                 } catch (Throwable t) {
5265                                                 Logger.defaultLogError(t);
5266                                                 }
5267                                         }
5268
5269                                         @Override
5270                                         public void exception(AsyncReadGraph graph, Throwable t) {
5271                                                 try {
5272                                                         procedure.exception(graph, t);
5273                                                 } catch (Throwable t2) {
5274                                                 Logger.defaultLogError(t2);
5275                                                 }
5276                                         }
5277
5278                                         @Override
5279                                         public String toString() {
5280                                                 return "forOrderedSet -> " + procedure;
5281                                         }
5282
5283                                 });
5284
5285         }
5286
5287         @Override
5288         public void forOrderedSet(Resource subject,
5289                         SyncMultiProcedure<Resource> procedure) {
5290                 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5291                                 procedure));
5292         }
5293
5294         @Override
5295         public void forOrderedSet(Resource subject,
5296                         MultiProcedure<Resource> procedure) {
5297                 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5298                                 procedure));
5299         }
5300
5301         @Override
5302         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5303                         AsyncListener<T> listener) {
5304                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5305         }
5306
5307         @Override
5308         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5309                         SyncListener<T> listener) {
5310                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5311         }
5312
5313         @Override
5314         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5315                         Listener<T> listener) {
5316                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5317         }
5318
5319         @Override
5320         final public <T> void forPossibleAdapted(final Resource resource,
5321                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
5322
5323                 assert (resource != null);
5324                 assert (clazz != null);
5325                 assert (procedure != null);
5326
5327                 final AdaptionService service = getSession().peekService(AdaptionService.class);
5328                 if (service == null)
5329                         procedure.exception(this, new ServiceException("No AdaptionService available"));
5330                 else
5331                         service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5332         }
5333
5334         @Override
5335         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5336                         SyncProcedure<T> procedure) {
5337                 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5338                                 procedure));
5339         }
5340
5341         @Override
5342         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5343                         Procedure<T> procedure) {
5344                 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5345                                 procedure));
5346         }
5347
5348         @Override
5349         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5350                         AsyncListener<T> listener) {
5351                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5352         }
5353
5354         @Override
5355         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5356                         SyncListener<T> listener) {
5357                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5358         }
5359
5360         @Override
5361         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5362                         Listener<T> listener) {
5363                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5364         }
5365
5366         @Override
5367         final public <T> void forPossibleUniqueAdapted(final Resource resource,
5368                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
5369
5370                 assert (resource != null);
5371                 assert (clazz != null);
5372                 assert (procedure != null);
5373
5374                 final AdaptionService service = getSession().peekService(AdaptionService.class);
5375                 if (service == null)
5376                         procedure.exception(this, new ServiceException("No AdaptionService available"));
5377                 else
5378                         service.adaptNew(this, resource, clazz, true, procedure);
5379
5380         }
5381
5382         @Override
5383         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5384                         SyncProcedure<T> procedure) {
5385                 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5386                                 procedure));
5387         }
5388
5389         @Override
5390         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5391                         Procedure<T> procedure) {
5392                 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5393                                 procedure));
5394         }
5395
5396         /*
5397          * Implementation of the interface AsyncRequestProcessor
5398          */
5399
5400         @Override
5401         final public Session getSession() {
5402                 return processor.getSession();
5403         }
5404
5405 //      @Override
5406 //      final public Builtins getBuiltins() {
5407 //              return processor.getSession().getBuiltins();
5408 //      }
5409
5410         @Override
5411         public <T> void asyncRequest(final Read<T> request) {
5412
5413                 asyncRequest(request, new AsyncProcedure<T>() {
5414
5415                         @Override
5416                         public void execute(AsyncReadGraph graph, T result) {
5417                         }
5418
5419                         @Override
5420                         public void exception(AsyncReadGraph graph, Throwable t) {
5421                                 Logger.defaultLogError(t);
5422                         }
5423
5424                         @Override
5425                         public String toString() {
5426                                 return "asyncRequest(Read) -> " + request;
5427                         }
5428
5429                 });
5430
5431         }
5432
5433         @Override
5434         public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5435                 asyncRequest(request, (AsyncProcedure<T>) procedure);
5436         }
5437
5438         @Override
5439         public <T> void asyncRequest(Read<T> request,
5440                         final SyncListener<T> procedure) {
5441                 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5442         }
5443
5444         @Override
5445         public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5446                 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5447         }
5448
5449         @Override
5450         public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5451
5452                 assert (request != null);
5453                 assert (procedure != null);
5454
5455                 processor.schedule(new SessionTask(false) {
5456
5457                         @Override
5458                         public void run(int thread) {
5459                                 try {
5460                                         final ListenerBase listener = getListenerBase(procedure);
5461                                         QueryCache.runnerReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
5462                                 } catch (DatabaseException e) {
5463                                         Logger.defaultLogError(e);
5464                                 }
5465                         }
5466
5467                 });
5468
5469         }
5470
5471     public static ReadGraphImpl createAsync(QueryProcessor support) {
5472         return new ReadGraphImpl(null, support);
5473     }
5474
5475     public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5476         return new ReadGraphImpl(entry, support);
5477     }
5478
5479         @Override
5480         public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5481                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5482         }
5483
5484         @Override
5485         public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5486                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5487         }
5488
5489         @Override
5490         final public <T> void asyncRequest(final AsyncRead<T> request) {
5491
5492                 assert (request != null);
5493
5494                 asyncRequest(request, new AsyncProcedure<T>() {
5495
5496                         @Override
5497                         public void execute(AsyncReadGraph graph, T result) {
5498                         }
5499
5500                         @Override
5501                         public void exception(AsyncReadGraph graph, Throwable t) {
5502                         Logger.defaultLogError(t);
5503                         }
5504
5505                         @Override
5506                         public String toString() {
5507                                 return "asyncRequest(AsyncRead) -> " + request;
5508                         }
5509
5510                 });
5511
5512         }
5513
5514         @Override
5515         public <T> void asyncRequest(AsyncRead<T> request,
5516                         AsyncListener<T> procedure) {
5517                 asyncRequest(request, (AsyncProcedure<T>) procedure);
5518         }
5519
5520         @Override
5521         final public <T> void asyncRequest(AsyncRead<T> request,
5522                         final SyncListener<T> procedure) {
5523                 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5524         }
5525
5526         @Override
5527         final public <T> void asyncRequest(AsyncRead<T> request,
5528                         final Listener<T> procedure) {
5529                 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5530         }
5531
5532         @Override
5533         final public <T> void asyncRequest(final AsyncRead<T> request,
5534                         final AsyncProcedure<T> procedure) {
5535
5536                 assert (request != null);
5537                 assert (procedure != null);
5538
5539                 processor.schedule(new SessionTask(false) {
5540
5541                         @Override
5542                         public void run(int thread) {
5543                                 try {
5544                                         final ListenerBase listener = getListenerBase(procedure);
5545                                         QueryCache.runnerAsyncReadEntry(ReadGraphImpl.this, request, parent, listener, procedure, false);
5546                                 } catch (DatabaseException e) {
5547                                         Logger.defaultLogError(e);
5548                                 }
5549                         }
5550
5551                 });
5552
5553         }
5554
5555         @Override
5556         public <T> void asyncRequest(AsyncRead<T> request,
5557                         SyncProcedure<T> procedure) {
5558                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5559         }
5560
5561         @Override
5562         final public <T> void asyncRequest(final AsyncRead<T> request,
5563                         final Procedure<T> procedure) {
5564                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5565         }
5566
5567         @Override
5568         public <T> void asyncRequest(final MultiRead<T> request) {
5569
5570                 assert (request != null);
5571
5572                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5573                         @Override
5574                         public void exception(AsyncReadGraph graph, Throwable t) {
5575                         Logger.defaultLogError(t);
5576                         }
5577
5578                         @Override
5579                         public String toString() {
5580                                 return "asyncRequest(MultiRead) -> " + request;
5581                         }
5582                 });
5583
5584         }
5585
5586         @Override
5587         public <T> void asyncRequest(MultiRead<T> request,
5588                         AsyncMultiListener<T> procedure) {
5589                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5590         }
5591
5592         @Override
5593         public <T> void asyncRequest(MultiRead<T> request,
5594                         SyncMultiListener<T> procedure) {
5595                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5596         }
5597
5598         @Override
5599         public <T> void asyncRequest(MultiRead<T> request,
5600                         MultiListener<T> procedure) {
5601                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5602         }
5603
5604         @Override
5605         public <T> void asyncRequest(final MultiRead<T> request,
5606                         final AsyncMultiProcedure<T> procedure) {
5607
5608                 assert (request != null);
5609                 assert (procedure != null);
5610
5611                 final ListenerBase listener = getListenerBase(procedure);
5612
5613                 if (parent != null || listener != null) {
5614
5615 //                  final ReadGraphImpl newGraph = newSync();
5616                     processor.query(this, request, parent, procedure,listener);
5617
5618                 } else {
5619
5620 //                  final ReadGraphImpl newGraph = newSync();
5621
5622                     try {
5623
5624                         request.perform(this, procedure);
5625
5626                     } catch (Throwable t) {
5627
5628                         procedure.exception(this, t);
5629
5630                     }
5631
5632                 }
5633
5634         }
5635
5636         @Override
5637         public <T> void asyncRequest(MultiRead<T> request,
5638                         SyncMultiProcedure<T> procedure) {
5639                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5640         }
5641
5642         @Override
5643         public <T> void asyncRequest(MultiRead<T> request,
5644                         MultiProcedure<T> procedure) {
5645                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5646         }
5647
5648         @Override
5649         final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5650
5651                 assert (request != null);
5652
5653                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5654                         @Override
5655                         public void exception(AsyncReadGraph graph, Throwable t) {
5656                         Logger.defaultLogError(t);
5657                         }
5658
5659                         @Override
5660                         public String toString() {
5661                                 return "asyncRequest(AsyncMultiRead) -> " + request;
5662                         }
5663                 });
5664
5665         }
5666
5667         @Override
5668         public <T> void asyncRequest(AsyncMultiRead<T> request,
5669                         AsyncMultiListener<T> procedure) {
5670                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5671         }
5672
5673         @Override
5674         public <T> void asyncRequest(AsyncMultiRead<T> request,
5675                         SyncMultiListener<T> procedure) {
5676                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5677         }
5678
5679         @Override
5680         public <T> void asyncRequest(AsyncMultiRead<T> request,
5681                         MultiListener<T> procedure) {
5682                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5683         }
5684
5685         @Override
5686         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5687                         final AsyncMultiProcedure<T> procedure) {
5688
5689                 assert (request != null);
5690                 assert (procedure != null);
5691
5692                 ListenerBase listener = getListenerBase(procedure);
5693
5694                 if (parent != null || listener != null) {
5695
5696                         processor.query(this, request, parent, procedure, listener);
5697
5698                 } else {
5699
5700                         try {
5701
5702                                 request.perform(this, new AsyncMultiProcedure<T>() {
5703
5704                                         @Override
5705                                         public void execute(AsyncReadGraph graph, T result) {
5706                                                 procedure.execute(graph, result);
5707                                         }
5708
5709                                         @Override
5710                                         public void finished(AsyncReadGraph graph) {
5711                                                 procedure.finished(graph);
5712                                         }
5713
5714                                         @Override
5715                                         public void exception(AsyncReadGraph graph, Throwable t) {
5716                                                 procedure.exception(graph, t);
5717                                         }
5718
5719                                         @Override
5720                                         public String toString() {
5721                                                 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5722                                         }
5723
5724                                 });
5725
5726                         } catch (Throwable t) {
5727
5728                                 procedure.exception(this, new DatabaseException(t));
5729
5730                         }
5731                 }
5732
5733         }
5734
5735         @Override
5736         public <T> void asyncRequest(AsyncMultiRead<T> request,
5737                         SyncMultiProcedure<T> procedure) {
5738                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5739         }
5740
5741         @Override
5742         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5743                         final MultiProcedure<T> procedure) {
5744                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5745         }
5746
5747         @Override
5748         final public <T> void asyncRequest(final ExternalRead<T> request) {
5749
5750                 assert (request != null);
5751
5752                 asyncRequest(request, new Procedure<T>() {
5753
5754                         @Override
5755                         public void execute(T result) {
5756                         }
5757
5758                         @Override
5759                         public void exception(Throwable t) {
5760                         Logger.defaultLogError(t);
5761                         }
5762
5763                         @Override
5764                         public String toString() {
5765                                 return "asyncRequest(PrimitiveRead) -> " + request;
5766                         }
5767
5768                 });
5769
5770         }
5771
5772         @Override
5773         public <T> void asyncRequest(ExternalRead<T> request,
5774                         final Listener<T> procedure) {
5775                 asyncRequest(request, (Procedure<T>) procedure);
5776         }
5777
5778         @Override
5779         final public <T> void asyncRequest(final ExternalRead<T> request,
5780                         final Procedure<T> procedure) {
5781
5782
5783         assert (request != null);
5784         assert (procedure != null);
5785
5786         final ListenerBase listener = getListenerBase(procedure);
5787
5788         if (parent != null || listener != null) {
5789
5790             try {
5791                 QueryCacheBase.resultExternalReadEntry(this, request, parent, listener, procedure);
5792                 //processor.query(this, request, parent, procedure,listener);
5793             } catch (DatabaseException e) {
5794                 Logger.defaultLogError(e);
5795                 // This throwable has already been transferred to procedure at this point - do nothing about it
5796                 //
5797             }
5798
5799         } else {
5800
5801             request.register(this, new Listener<T>() {
5802                 //
5803                 @Override
5804                 public void execute(T result) {
5805                     procedure.execute(result);
5806                 }
5807
5808                 @Override
5809                 public void exception(Throwable t) {
5810                     procedure.exception(t);
5811                 }
5812
5813                 @Override
5814                 public String toString() {
5815                     return "asyncRequest(PrimitiveRead) -> " + request;
5816                 }
5817
5818                 @Override
5819                 public boolean isDisposed() {
5820                     return true;
5821                 }
5822
5823             });
5824
5825 //          final ReadGraphImpl newGraph = newSync();
5826
5827 //            try {
5828 //
5829 //                T result = request.perform(this);
5830 //
5831 //                try {
5832 //                    procedure.execute(this, result);
5833 //                } catch (Throwable t) {
5834 //                    Logger.defaultLogError(t);
5835 //                }
5836 //
5837 //            } catch (Throwable t) {
5838 //
5839 //                try {
5840 //                    procedure.exception(this, t);
5841 //                } catch (Throwable t2) {
5842 //                    Logger.defaultLogError(t2);
5843 //                }
5844 //
5845 //            } finally {
5846 //
5847 //            }
5848
5849         }
5850
5851 //              assert (request != null);
5852 //              assert (procedure != null);
5853 //
5854 //              ListenerBase listener = getListenerBase(procedure);
5855 //
5856 //              if (parent != null || listener != null) {
5857 //
5858 //                      processor.query(this, request, parent, procedure, listener);
5859 //
5860 //              } else {
5861 //
5862 //                      try {
5863 //
5864 //                              request.register(this, new Listener<T>() {
5865 //
5866 //                                      @Override
5867 //                                      public void execute(T result) {
5868 //                                              procedure.execute(result);
5869 //                                      }
5870 //
5871 //                                      @Override
5872 //                                      public void exception(Throwable t) {
5873 //                                              procedure.exception(t);
5874 //                                      }
5875 //
5876 //                                      @Override
5877 //                                      public String toString() {
5878 //                                              return "asyncRequest(PrimitiveRead) -> " + request;
5879 //                                      }
5880 //
5881 //                                      @Override
5882 //                                      public boolean isDisposed() {
5883 //                                              return true;
5884 //                                      }
5885 //
5886 //                              });
5887 //
5888 //                      } catch (Throwable t) {
5889 //
5890 //                              if (t instanceof DatabaseException)
5891 //                                      procedure.exception(t);
5892 //                              else
5893 //                                      procedure
5894 //                                                      .exception(new DatabaseException(
5895 //                                                                      "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5896 //                                                                      t));
5897 //
5898 //                      }
5899 //
5900 //              }
5901
5902         }
5903
5904         @Override
5905         public void asyncRequest(final Write request) {
5906
5907                 assert (request != null);
5908
5909                 getSession().asyncRequest(request);
5910
5911 //              processor.asyncWrite(request);
5912
5913         }
5914
5915         @Override
5916         public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5917                 throw new Error("Not implemented.");
5918         }
5919
5920         @Override
5921         public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5922
5923                 assert (request != null);
5924
5925                 getSession().asyncRequest(request, callback);
5926
5927         }
5928
5929         @Override
5930         public void asyncRequest(final DelayedWrite request) {
5931
5932                 assert (request != null);
5933
5934                 getSession().asyncRequest(request);
5935
5936         }
5937
5938         @Override
5939         public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5940                 throw new Error("Not implemented.");
5941         }
5942
5943         @Override
5944         public void asyncRequest(DelayedWrite r,
5945                         Consumer<DatabaseException> callback) {
5946                 throw new Error("Not implemented.");
5947         }
5948
5949         @Override
5950         public void asyncRequest(final WriteOnly request) {
5951
5952                 assert (request != null);
5953
5954                 getSession().asyncRequest(request);
5955
5956         }
5957
5958         @Override
5959         public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5960                 throw new Error("Not implemented.");
5961         }
5962
5963         @Override
5964         public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5965                 throw new Error("Not implemented.");
5966         }
5967
5968         /*
5969          * Implementation of the interface ServiceLocator
5970          */
5971
5972         @Override
5973         public <T> T getService(Class<T> api) {
5974             if(WriteSupport.class == api) {
5975                 if(this instanceof WriteGraphImpl) {
5976                     WriteGraphImpl impl = (WriteGraphImpl)this;
5977                     return (T)impl.writeSupport;
5978                 }
5979             }
5980                 return getSession().getService(api);
5981         }
5982
5983         @Override
5984         public <T> T peekService(Class<T> api) {
5985                 return getSession().peekService(api);
5986         }
5987
5988         @Override
5989         public boolean hasService(Class<?> api) {
5990                 return getSession().hasService(api);
5991         }
5992
5993         @Override
5994         public <T> void registerService(Class<T> api, T service) {
5995                 getSession().registerService(api, service);
5996         }
5997
5998         @Override
5999         public boolean isImmutable(Resource resource) throws DatabaseException {
6000                 ResourceImpl impl = (ResourceImpl)resource;
6001                 return processor.isImmutable(impl.id);
6002         }
6003
6004         /*
6005          * Internal routines
6006          */
6007
6008         protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
6009
6010         /*
6011          * callerThread is the currently running thread state.syncThread is blocking for
6012          * this execution state.syncParent is the blocking request
6013          */
6014
6015         final private boolean isExternal(int thread) {
6016                 return thread == Integer.MIN_VALUE;
6017         }
6018
6019 //      final private boolean isSync(int thread) {
6020 //              return thread < -1 && thread > Integer.MIN_VALUE;
6021 //      }
6022
6023         ReadGraphImpl(ReadGraphImpl graph) {
6024                 this(graph.parent, graph.processor);
6025         }
6026
6027         ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
6028 //              this.state = new ReadGraphState(barrier, support);
6029                 this.parent = parent;
6030                 this.processor = support;
6031         }
6032
6033         ReadGraphImpl(final QueryProcessor support) {
6034
6035 //              this.state = state;
6036                 this.processor = support;
6037                 this.parent = null;
6038
6039         }
6040
6041 //      public static ReadGraphImpl createSync(int syncThread, Object syncParent,
6042 //                      ReadGraphSupportImpl support) {
6043 //              return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
6044 //                              support, new AsyncBarrierImpl(null));
6045 //      }
6046
6047         public static ReadGraphImpl create(QueryProcessor support) {
6048                 return new ReadGraphImpl(support);
6049         }
6050
6051 //      public ReadGraphImpl newAsync() {
6052 //              return this;
6053 ////            if(!state.synchronizedExecution) {
6054 ////                    return this;
6055 ////            } else {
6056 ////                    return new ReadGraphImpl(false, parent, state.support, state.barrier);
6057 ////            }
6058 //      }
6059
6060 //      public ReadGraphImpl newSync() {
6061 //              return new ReadGraphImpl(parent, processor);
6062 //      }
6063
6064         public ReadGraphImpl newSync(CacheEntry parentEntry) {
6065                 return new ReadGraphImpl(parentEntry, processor);
6066         }
6067
6068         public ReadGraphImpl newRestart(ReadGraphImpl impl) {
6069
6070                 WriteGraphImpl write = processor.getSession().getService(
6071                                 WriteGraphImpl.class);
6072
6073 //              if (write.callerThread != impl.callerThread)
6074 //                      return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
6075                 return write;
6076
6077         }
6078
6079 //      public ReadGraphImpl newSync(Object parentRequest) {
6080 //              return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6081 //      }
6082
6083 //      public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
6084 //              assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
6085 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6086 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6087 //      }
6088 //
6089 //      public ReadGraphImpl newSyncAsync(Object parentRequest) {
6090 ////            assert (callerThread < 0);
6091 //              return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6092 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6093 //      }
6094 //
6095 //      public ReadGraphImpl newSyncAsync(final int callerThread,
6096 //                      Object parentRequest) {
6097 ////            assert (callerThread < 0);
6098 //              // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6099 //              // && callerThread != Integer.MIN_VALUE) );
6100 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6101 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6102 //      }
6103
6104         public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6105                 return new ReadGraphImpl(parent, processor);
6106         }
6107
6108         public ReadGraphImpl withParent(CacheEntry parent) {
6109                 if(parent == this.parent) return this;
6110                 else return new ReadGraphImpl(parent, processor);
6111         }
6112
6113         final private ListenerBase getListenerBase(final Object procedure) {
6114                 if (procedure instanceof ListenerBase)
6115                         return (ListenerBase) procedure;
6116                 else
6117                         return null;
6118         }
6119
6120         public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6121
6122                 assert(procedure.done());
6123
6124 //              while (!procedure.done()) {
6125 //
6126 //                      boolean executed = processor.resumeTasks(callerThread, null, null);
6127 //                      if (!executed) {
6128 //                              try {
6129 //                                      Thread.sleep(1);
6130 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6131 //                              } catch (InterruptedException e) {
6132 //                                      e.printStackTrace();
6133 //                              }
6134 //                      }
6135 //
6136 //              }
6137
6138         }
6139
6140         public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6141
6142                 assert(procedure.done());
6143
6144 //              while (!procedure.done()) {
6145 //
6146 //                      boolean executed = processor.processor.resume(this);
6147 //                      if (!executed) {
6148 //                              try {
6149 //                                      Thread.sleep(1);
6150 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6151 //                              } catch (InterruptedException e) {
6152 //                                      e.printStackTrace();
6153 //                              }
6154 //                      }
6155 //
6156 //              }
6157
6158         }
6159
6160 //      public void waitAsync(Object request) {
6161 //              try {
6162 //                      state.barrier.waitBarrier(request, this);
6163 //              } catch (Throwable t) {
6164 //                      t.printStackTrace();
6165 //                      processor.scanPending();
6166 //                      processor.querySupport.checkTasks();
6167 //                      throw new RuntimeDatabaseException(t);
6168 //              }
6169 //      }
6170
6171 //      public void restart() {
6172 //              state.barrier.restart();
6173 //      }
6174
6175         public boolean resumeTasks() {
6176                 return processor.resumeTasks(this);
6177         }
6178
6179         Class<?> singleClass(Set<Resource> types) {
6180                 Class<?> result = null;
6181                 for (Resource type : types) {
6182                         Class<?> clazz = processor.getBuiltinValue(type);
6183                         if (clazz != null) {
6184                                 if (result != null)
6185                                         return null;
6186                                 else
6187                                         result = clazz;
6188                         }
6189                 }
6190                 return result;
6191         }
6192
6193         private String debugString(Resource r) {
6194                 String name = null;
6195                 try {
6196                         name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6197                 } catch (ManyObjectsForFunctionalRelationException e) {
6198                 Logger.defaultLogError(e);
6199                 } catch (ServiceException e) {
6200                 Logger.defaultLogError(e);
6201                 }
6202                 return "[" + name + " - " + r + "]";
6203         }
6204
6205         @Override
6206         public String toString() {
6207                 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6208         }
6209
6210         @Override
6211         final public int thread() {
6212                 return 0;
6213         }
6214
6215     static class MultiTripleIntProcedure implements TripleIntProcedure {
6216
6217         final private AsyncMultiProcedure<Statement> procedure;
6218         final private ReadGraphImpl impl;
6219         final private QuerySupport support;
6220
6221         public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6222                 this.procedure = procedure;
6223                 this.impl = impl;
6224                 this.support = support;
6225         }
6226
6227         @Override
6228         public void execute(ReadGraphImpl graph, int s, int p, int o) {
6229                 try {
6230                         procedure.execute(graph, support.getStatement(s, p, o));
6231                 } catch (Throwable t2) {
6232                         Logger.defaultLogError(t2);
6233                 }
6234         }
6235
6236         @Override
6237         public void finished(ReadGraphImpl graph) {
6238                 try {
6239                         procedure.finished(graph);
6240 //                      impl.state.barrier.dec("ReadGraphSupportImpl.516");
6241                 } catch (Throwable t2) {
6242                         Logger.defaultLogError(t2);
6243                 }
6244         }
6245
6246         @Override
6247         public void exception(ReadGraphImpl graph, Throwable t) {
6248                 try {
6249                         procedure.exception(graph, t);
6250                 } catch (Throwable t2) {
6251                         Logger.defaultLogError(t2);
6252                 }
6253 //              impl.state.barrier.dec("ReadGraphSupportImpl.516");
6254         }
6255
6256         @Override
6257         public String toString() {
6258                 return "forEachObject with " + procedure;
6259         }
6260
6261     }
6262
6263 //    private AsyncMultiProcedure<Resource> cacheKey = null;
6264 //    private MultiIntProcedure cacheResult = null;
6265 //
6266 //    final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6267 //
6268 //      if(procedure == cacheKey) return cacheResult;
6269 //
6270 //      cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6271 //      cacheKey = procedure;
6272 //
6273 //      return cacheResult;
6274 //
6275 //    }
6276 //
6277 //    private AsyncMultiProcedure<Statement> cacheKey2 = null;
6278 //    private MultiTripleIntProcedure cacheResult2 = null;
6279 //
6280 //    final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6281 //
6282 //      if(procedure == cacheKey2) return cacheResult2;
6283 //
6284 //      cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6285 //      cacheKey2 = procedure;
6286 //
6287 //      return cacheResult2;
6288 //
6289 //    }
6290
6291     @Override
6292     public Datatype getDataType(Resource subject) throws DatabaseException {
6293         for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6294                 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6295         throw new DoesNotContainValueException("The literal has no data type.");
6296     }
6297
6298     protected <T extends Accessor> T getAccessor4File(Resource subject)
6299     throws DatabaseException {
6300         return null;
6301         /*
6302         byte[]  bytes = processor.support.getValue(g, subject);
6303         if (null == bytes)
6304             return null;
6305         try {
6306             BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6307             Accessor ca = va.getContentAccessor();
6308             return (T)ca;
6309         } catch (AccessorConstructionException e) {
6310             throw new DatabaseException(e);
6311         }
6312         */
6313         /*
6314         if (null == bytes)
6315             return null;
6316         Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6317         Serializer datatype_serializer = datatype_binding.serializer();
6318         DataType datatype;
6319         try {
6320             BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6321             datatype = (DataType)datatype_serializer.deserialize(in);
6322             Binding data_binding = Bindings.getBinding(datatype);
6323             Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6324             Object o = data_serializer.deserialize(in);
6325             try {
6326                 return (T)Accessors.getAccessor(data_binding, o);
6327             } catch(AccessorConstructionException e) {
6328                 return null;
6329             }
6330         } catch (Exception e) {
6331             throw new DatabaseException(e);
6332         }*/
6333     }
6334     @SuppressWarnings("unchecked")
6335     @Override
6336     public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6337         RandomAccessBinary rab = getRandomAccessBinary(subject);
6338         try {
6339             return (T)Accessors.getAccessor(rab, getDataType(subject));
6340         } catch(AccessorConstructionException e) {
6341             throw new DatabaseException(e);
6342         }
6343     }
6344     @SuppressWarnings("unchecked")
6345     protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6346     throws DatabaseException {
6347         RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6348         try {
6349             return (T)Accessors.getAccessor(rab, datatype);
6350         } catch(AccessorConstructionException e) {
6351             throw new DatabaseException(e);
6352         }
6353     }
6354     @Override
6355     public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6356         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6357         ResourceData rd = ravs.get(subject);
6358         if (null != rd)
6359             return rd;
6360         try {
6361             ExternalValueSupport evs = getService(ExternalValueSupport.class);
6362             long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6363             try {
6364                 File platform = Platform.getLocation().toFile();
6365                 File tempFiles = new File(platform, "tempFiles");
6366                 File dbDir = new File(tempFiles, "db");
6367                 dbDir.mkdirs();
6368                 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6369                 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6370                 final int N = 1<<20;
6371                 long left = size;
6372                 long offset = 0;
6373                 while (left > 0) {
6374                     int length = N < left ? N : (int)left;
6375                     byte[] bytes = evs.readValue(this, subject, offset, length);
6376                     offset += bytes.length;
6377                     left -= bytes.length;
6378                     rd.binaryFile.write(bytes);
6379                 }
6380                 ravs.put(subject, rd);
6381                 return rd;
6382             } catch (Exception e) {
6383                 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6384             }
6385         } catch (Exception e) {
6386             if(Development.DEVELOPMENT) {
6387                 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6388                     e.printStackTrace();
6389                 }
6390             }
6391         }
6392         Datatype datatype = getDataType(subject);
6393         Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6394         return createRandomAccessBinary(subject, datatype, value);
6395     }
6396     public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6397     throws DatabaseException {
6398         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6399         try {
6400             File platform = Platform.getLocation().toFile();
6401             File tempFiles = new File(platform, "tempFiles");
6402             File dbDir = new File(tempFiles, "db");
6403             dbDir.mkdirs();
6404             File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6405             ResourceData rd = new ResourceData(new BinaryFile(file), false);
6406             Binding binding = Bindings.getBinding(datatype);
6407             if (null == initialValue) {
6408                 initialValue = binding.createDefault();
6409             }
6410             Serializer serializer = binding.serializer();
6411             byte[] bytes = serializer.serialize(initialValue);
6412             rd.binaryFile.write(bytes);
6413             ravs.put(resource, rd);
6414             return rd;
6415         } catch (Exception e) {
6416             if (e instanceof DatabaseException)
6417                 throw (DatabaseException)e;
6418             else
6419                 throw new DatabaseException(e);
6420         }
6421     }
6422
6423 //    static class ExternalValueRequest<T> extends ResourceRead<T> {
6424 //
6425 //              public ExternalValueRequest(Resource resource) {
6426 //                      super(resource);
6427 //              }
6428 //
6429 //              @SuppressWarnings("unchecked")
6430 //              @Override
6431 //              public T perform(ReadGraph graph) throws DatabaseException {
6432 //              try {
6433 //
6434 //                      String uri = graph.getURI(resource);
6435 //                      if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6436 //
6437 //                      return (T)ReflectionUtils.getValue(uri).getValue();
6438 //
6439 //              } catch(ValueNotFoundException e) {
6440 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6441 //              } catch(ClassCastException e) {
6442 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6443 //              }
6444 //              }
6445 //
6446 //    }
6447
6448     @SuppressWarnings("unchecked")
6449     @Override
6450     public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6451         Layer0 L0 = processor.getL0(this);
6452         Set<Resource> types = getTypes(r);
6453
6454         if(types.contains(L0.Literal)) {
6455                 if(isImmutable(r)) {
6456                         return syncRequest(new ValueImplied<T>(r));
6457                 } else {
6458                         return getValue(r);
6459                 }
6460         }
6461         else if(types.contains(L0.Function)) {
6462             return Functions.exec(this, r, this, r, context);
6463         }
6464         else if(types.contains(L0.ExternalValue)) {
6465                 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6466         }
6467         else {
6468
6469             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6470             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6471             try {
6472                 return function.apply(this, r, context);
6473             } catch(RuntimeException e) {
6474                 DatabaseException dte = findPossibleRootException(e);
6475                 if(dte != null) throw dte;
6476                 else throw new DatabaseException(e);
6477             }
6478
6479         }
6480     }
6481
6482     @Override
6483     public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6484         Layer0 L0 = processor.getL0(this);
6485         Set<Resource> types = getTypes(r);
6486
6487         if(types.contains(L0.Literal)) {
6488             if(isImmutable(r)) {
6489                 return syncRequest(new VariantValueImplied(r));
6490             } else {
6491                 return getVariantValue(r);
6492             }
6493         }
6494         else if(types.contains(L0.Function)) {
6495             Object value = Functions.exec(this, r, this, r, context);
6496             try {
6497                 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6498             } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6499                 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6500             }
6501         }
6502         else if(types.contains(L0.ExternalValue)) {
6503             Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6504             try {
6505                 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6506             } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6507                 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6508             }
6509         }
6510         else {
6511
6512             Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6513             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6514             try {
6515                 Object value = function.apply(this, r, context);
6516                 try {
6517                     return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6518                 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6519                     throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6520                 }
6521             } catch(RuntimeException e) {
6522                 DatabaseException dte = findPossibleRootException(e);
6523                 if(dte != null) throw dte;
6524                 else throw new DatabaseException(e);
6525             }
6526         }
6527     }
6528
6529     @Override
6530     public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6531         try {
6532                 return getValue2(subject, context);
6533         } catch (DatabaseException e) {
6534                 return null;
6535         }
6536     }
6537
6538     static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6539
6540         public PossibleConverterFunction(Resource resource) {
6541                         super(resource);
6542                 }
6543
6544         @Override
6545         public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6546                 return compute(graph, resource);
6547         }
6548
6549         @SuppressWarnings("unchecked")
6550                 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6551             Layer0 L0 = Layer0.getInstance(graph);
6552             for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6553                 try {
6554                         if(L0.Functions_functionApplication.equals(converter)) {
6555                                 return AdaptValue.functionApplication;
6556                                 //return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6557                         } else {
6558                                 return graph.getValue2(converter, resource);
6559                         }
6560                 } catch(RuntimeException e) {
6561                     DatabaseException dte = findPossibleRootException(e);
6562                     if(dte != null) throw dte;
6563                     else throw new DatabaseException(e);
6564                 }
6565             }
6566             return null;
6567         }
6568
6569     }
6570
6571     <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6572         if(isImmutable(r))
6573                 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6574         else
6575                 return syncRequest(new PossibleConverterFunction<T>(r));
6576     }
6577
6578     /**
6579      * Get a value associated with a graph {@link Resource}, using a possible context object and
6580      * a desired value binding. The following methods are tried in order to retreive the value:
6581      * <ol>
6582      *   <li>If the given resource is a {@code L0.Literal}, the value of the literal is returned, using the binding specified by {@code binding}.</li>
6583      *   <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6584      *       {@link ReflectionUtils#getValue(String)}.</li>
6585      *   <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6586      *       (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6587      *       and the context object.</li>
6588      * </ul>
6589      *
6590      * @param r  A graph resource with which the value is associated
6591      * @param context  A context object that is used for acquiring the value (only applied in case 3)
6592      * @param binding  A binding for the value type (only applied in case 1)
6593      * @return  The value of the graph node.
6594      * @throws DoesNotContainValueException  No value is associated with the graph node.
6595      * @throws DatabaseException  Other errors, such as an error in casting the value to the return type or
6596      *         a runtime error in the value function.
6597      */
6598     @SuppressWarnings("unchecked")
6599         @Override
6600     public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6601         if (binding instanceof ObjectVariantBinding)
6602                 return getValue2(r, context);
6603
6604         Layer0 L0 = processor.getL0(this);
6605         Set<Resource> types = getTypes(r);
6606         if(types.contains(L0.Literal)) {
6607                 if(isImmutable(r)) {
6608                         return syncRequest(new Value<T>(r, binding));
6609                 } else {
6610                         return getValue(r, binding);
6611                 }
6612         } else if(types.contains(L0.Function)) {
6613             Object value = Functions.exec(this, r, this, r, context);
6614             if(binding.isInstance(value)) return (T)value;
6615             try {
6616                 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6617                 return (T)Bindings.adapt(value, srcBinding, binding);
6618             } catch(RuntimeException e) {
6619                 DatabaseException dte = findPossibleRootException(e);
6620                 if(dte != null) throw dte;
6621                 else throw new DatabaseException(e);
6622             } catch (AdaptException e) {
6623                 throw new DatabaseException(e);
6624             } catch (org.simantics.databoard.binding.error.BindingException e) {
6625                 throw new DatabaseException(e);
6626             }
6627         } else if(types.contains(L0.ExternalValue)) {
6628                 try {
6629                         ExternalValue ev = adapt(r, ExternalValue.class);
6630                         return ev.getValue(this, r);
6631                         //return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6632 //              } catch(ValueNotFoundException e) {
6633 //                      throw new DatabaseException(e);
6634                 } catch(ClassCastException e) {
6635                         throw new DatabaseException(e);
6636                 }
6637         }
6638         else {
6639             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6640             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6641             try {
6642                 Object value = function.apply(this, r, context);
6643                 if(binding.isInstance(value)) return (T)value;
6644                 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6645                 return (T)Bindings.adapt(value, srcBinding, binding);
6646             } catch(RuntimeException e) {
6647                 DatabaseException dte = findPossibleRootException(e);
6648                 if(dte != null) throw dte;
6649                 else throw new DatabaseException(e);
6650             } catch (AdaptException e) {
6651                 throw new DatabaseException(e);
6652                         } catch (org.simantics.databoard.binding.error.BindingException e) {
6653                 throw new DatabaseException(e);
6654                         }
6655         }
6656     }
6657
6658     @Override
6659     public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6660         try {
6661                 return getValue2(subject, context, binding);
6662         } catch (DatabaseException e) {
6663                 return null;
6664         }
6665     }
6666
6667         private static DatabaseException findPossibleRootException(Throwable t) {
6668                 if(t == null) return null;
6669                 if(t instanceof DatabaseException) return (DatabaseException)t;
6670                 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6671                         return findPossibleRootException(t.getCause());
6672                 }
6673                 return null;
6674         }
6675
6676     @Override
6677     public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6678         return getRelatedValue2(subject, relation, subject);
6679     }
6680
6681     @Override
6682     public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6683         return getRelatedVariantValue2(subject, relation, subject);
6684     }
6685
6686     @Override
6687     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6688         try {
6689                 Resource object = getPossibleObject(subject, relation);
6690                 if(object == null) return null;
6691                 else return getValue2(object, subject);
6692         } catch (DatabaseException e) {
6693                 return null;
6694         }
6695     }
6696
6697     @Override
6698     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6699                 if(Development.DEVELOPMENT) {
6700                         String error = L0Validations.checkValueType(this, subject, relation);
6701                         if(error != null) {
6702                                 Logger.defaultLogError(new ValidationException(error));
6703                                 //throw new ValidationException(error);
6704                                 new ValidationException(error).printStackTrace();
6705                         }
6706                 }
6707         return getValue2(getSingleObject(subject, relation), context);
6708     }
6709
6710     @Override
6711     public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6712         if(Development.DEVELOPMENT) {
6713             String error = L0Validations.checkValueType(this, subject, relation);
6714             if(error != null) {
6715                 Logger.defaultLogError(new ValidationException(error));
6716                 //throw new ValidationException(error);
6717                 new ValidationException(error).printStackTrace();
6718             }
6719         }
6720         return getVariantValue2(getSingleObject(subject, relation), context);
6721     }
6722
6723     @Override
6724     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6725         try {
6726                 Resource object = getPossibleObject(subject, relation);
6727                 if(object == null) return null;
6728                 else return getValue2(object, context);
6729         } catch (DatabaseException e) {
6730                 return null;
6731         }
6732     }
6733
6734     @Override
6735     public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6736         return getRelatedValue2(subject, relation, subject, binding);
6737     }
6738
6739     @Override
6740     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6741         try {
6742                 Resource object = getPossibleObject(subject, relation);
6743                 if(object == null) return null;
6744                 return getValue2(object, subject, binding);
6745         } catch (DatabaseException e) {
6746                 return null;
6747         }
6748     }
6749
6750     @Override
6751     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6752         return getValue2(getSingleObject(subject, relation), context, binding);
6753     }
6754
6755     @Override
6756     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6757         try {
6758                 Resource object = getPossibleObject(subject, relation);
6759                 if(object == null) return null;
6760                 else return getValue2(object, context, binding);
6761         } catch (DatabaseException e) {
6762                 return null;
6763         }
6764     }
6765
6766     @Override
6767     public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6768         Layer0 L0 = processor.getL0(this);
6769         Resource property = getSingleObject(subject, relation);
6770         String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6771         try {
6772             return org.simantics.scl.compiler.types.Types.parseType(typeText);
6773         } catch (SCLTypeParseException e) {
6774             throw new DatabaseException(e);
6775         }
6776     }
6777
6778     private static ThreadLocal<Boolean> syncGraph = new ThreadLocal<Boolean>() {
6779         protected Boolean initialValue() {
6780             return true;
6781         }
6782     };
6783
6784     @Override
6785     public boolean setSynchronous(boolean value) {
6786         boolean old = getSynchronous();
6787         syncGraph.set(value);
6788         return old;
6789     }
6790
6791     @Override
6792     public boolean getSynchronous() {
6793         return syncGraph.get();
6794     }
6795
6796     public void ensureLoaded(int resource) {
6797         processor.querySupport.ensureLoaded(this, resource);
6798     }
6799
6800     public void ensureLoaded(int resource, int predicate) {
6801         processor.querySupport.ensureLoaded(this, resource, predicate);
6802     }
6803
6804     public byte[] getValue(int resource) {
6805         return processor.querySupport.getValue(this, resource);
6806     }
6807
6808     public int thread(int resource) {
6809         return (resource >>> 16) & processor.THREAD_MASK;
6810     }
6811
6812     public int thread(Resource resource) {
6813         return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6814     }
6815
6816     public ResourceSupport getResourceSupport() {
6817         return processor.getResourceSupport();
6818     }
6819
6820     @Override
6821     public Object getModificationCounter() {
6822         return processor.getSession().getModificationCounter();
6823     }
6824
6825         @Override
6826         public boolean performPending() {
6827                 return processor.performPending(processor.thread.get());
6828         }
6829
6830 }