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