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