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.ExternalValueSupport;
  49 import org.simantics.db.ReadGraph;
  50 import org.simantics.db.RelationContext;
  51 import org.simantics.db.Resource;
  52 import org.simantics.db.Session;
  53 import org.simantics.db.Statement;
  54 import org.simantics.db.adaption.AdaptionService;
  55 import org.simantics.db.common.primitiverequest.Adapter;
  56 import org.simantics.db.common.primitiverequest.Builtin;
  57 import org.simantics.db.common.primitiverequest.DatatypeBinding;
  58 import org.simantics.db.common.primitiverequest.ForEachAssertedObject;
  59 import org.simantics.db.common.primitiverequest.ForEachAssertedStatement;
  60 import org.simantics.db.common.primitiverequest.HasStatement;
  61 import org.simantics.db.common.primitiverequest.HasStatementSubject;
  62 import org.simantics.db.common.primitiverequest.HasStatementSubjectObject;
  63 import org.simantics.db.common.primitiverequest.HasValue;
  64 import org.simantics.db.common.primitiverequest.Inverse;
  65 import org.simantics.db.common.primitiverequest.IsInheritedFrom;
  66 import org.simantics.db.common.primitiverequest.IsInstanceOf;
  67 import org.simantics.db.common.primitiverequest.IsSubrelationOf;
  68 import org.simantics.db.common.primitiverequest.OrderedSet;
  69 import org.simantics.db.common.primitiverequest.PossibleAdapter;
  70 import org.simantics.db.common.primitiverequest.PossibleInverse;
  71 import org.simantics.db.common.primitiverequest.PossibleObject;
  72 import org.simantics.db.common.primitiverequest.PossibleRelatedValue;
  73 import org.simantics.db.common.primitiverequest.PossibleRelatedValueImplied;
  74 import org.simantics.db.common.primitiverequest.PossibleStatement;
  75 import org.simantics.db.common.primitiverequest.PossibleType;
  76 import org.simantics.db.common.primitiverequest.PossibleUniqueAdapter;
  77 import org.simantics.db.common.primitiverequest.PossibleValue;
  78 import org.simantics.db.common.primitiverequest.PossibleValueImplied;
  79 import org.simantics.db.common.primitiverequest.RelatedValue;
  80 import org.simantics.db.common.primitiverequest.RelatedValueImplied;
  81 import org.simantics.db.common.primitiverequest.SingleObject;
  82 import org.simantics.db.common.primitiverequest.SingleStatement;
  83 import org.simantics.db.common.primitiverequest.SingleType;
  84 import org.simantics.db.common.primitiverequest.SingleTypeAny;
  85 import org.simantics.db.common.primitiverequest.Types;
  86 import org.simantics.db.common.primitiverequest.UniqueAdapter;
  87 import org.simantics.db.common.primitiverequest.Value;
  88 import org.simantics.db.common.primitiverequest.ValueImplied;
  89 import org.simantics.db.common.primitiverequest.VariantValueImplied;
  90 import org.simantics.db.common.procedure.adapter.AsyncMultiProcedureAdapter;
  91 import org.simantics.db.common.procedure.adapter.ProcedureAdapter;
  92 import org.simantics.db.common.procedure.adapter.TransientCacheAsyncListener;
  93 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
  94 import org.simantics.db.common.procedure.single.SyncReadProcedure;
  95 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrErrorProcedure;
  96 import org.simantics.db.common.procedure.single.wrapper.DeepSingleOrNullProcedure;
  97 import org.simantics.db.common.procedure.single.wrapper.ExceptionToNullProcedure;
  98 import org.simantics.db.common.procedure.single.wrapper.NullSingleOrNullProcedure;
  99 import org.simantics.db.common.procedure.single.wrapper.SingleFunctionalOrNullProcedure;
 100 import org.simantics.db.common.procedure.single.wrapper.SingleOrErrorProcedure;
 101 import org.simantics.db.common.procedure.single.wrapper.SingleOrNullProcedure;
 102 import org.simantics.db.common.procedure.wrapper.NoneToAsyncListener;
 103 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiListener;
 104 import org.simantics.db.common.procedure.wrapper.NoneToAsyncMultiProcedure;
 105 import org.simantics.db.common.procedure.wrapper.NoneToAsyncProcedure;
 106 import org.simantics.db.common.procedure.wrapper.NoneToAsyncSetProcedure;
 107 import org.simantics.db.common.procedure.wrapper.SyncToAsyncListener;
 108 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiListener;
 109 import org.simantics.db.common.procedure.wrapper.SyncToAsyncMultiProcedure;
 110 import org.simantics.db.common.procedure.wrapper.SyncToAsyncProcedure;
 111 import org.simantics.db.common.procedure.wrapper.SyncToAsyncSetProcedure;
 112 import org.simantics.db.common.request.AdaptValue;
 113 import org.simantics.db.common.request.ResourceRead;
 114 import org.simantics.db.common.utils.Logger;
 115 import org.simantics.db.common.utils.NameUtils;
 116 import org.simantics.db.common.validation.L0Validations;
 117 import org.simantics.db.exception.AdaptionException;
 118 import org.simantics.db.exception.ArgumentException;
 119 import org.simantics.db.exception.AssumptionException;
 120 import org.simantics.db.exception.BindingException;
 121 import org.simantics.db.exception.DatabaseException;
 122 import org.simantics.db.exception.DoesNotContainValueException;
 123 import org.simantics.db.exception.EmptyResourceException;
 124 import org.simantics.db.exception.InternalException;
 125 import org.simantics.db.exception.InvalidLiteralException;
 126 import org.simantics.db.exception.ManyObjectsForFunctionalRelationException;
 127 import org.simantics.db.exception.NoInverseException;
 128 import org.simantics.db.exception.NoSingleResultException;
 129 import org.simantics.db.exception.ResourceNotFoundException;
 130 import org.simantics.db.exception.ServiceException;
 131 import org.simantics.db.exception.ValidationException;
 132 import org.simantics.db.impl.RelationContextImpl;
 133 import org.simantics.db.impl.ResourceImpl;
 134 import org.simantics.db.impl.internal.RandomAccessValueSupport;
 135 import org.simantics.db.impl.internal.ResourceData;
 136 import org.simantics.db.impl.procedure.CallWrappedSingleQueryProcedure4;
 137 import org.simantics.db.impl.procedure.ResultCallWrappedQueryProcedure4;
 138 import org.simantics.db.impl.procedure.ResultCallWrappedSingleQueryProcedure4;
 139 import org.simantics.db.impl.query.CacheEntry;
 140 import org.simantics.db.impl.query.QueryProcessor;
 141 import org.simantics.db.impl.query.QuerySupport;
 142 import org.simantics.db.impl.query.TripleIntProcedure;
 143 import org.simantics.db.impl.support.ResourceSupport;
 144 import org.simantics.db.procedure.AsyncListener;
 145 import org.simantics.db.procedure.AsyncMultiListener;
 146 import org.simantics.db.procedure.AsyncMultiProcedure;
 147 import org.simantics.db.procedure.AsyncProcedure;
 148 import org.simantics.db.procedure.AsyncSetListener;
 149 import org.simantics.db.procedure.Listener;
 150 import org.simantics.db.procedure.ListenerBase;
 151 import org.simantics.db.procedure.MultiListener;
 152 import org.simantics.db.procedure.MultiProcedure;
 153 import org.simantics.db.procedure.Procedure;
 154 import org.simantics.db.procedure.SetListener;
 155 import org.simantics.db.procedure.StatementProcedure;
 156 import org.simantics.db.procedure.SyncListener;
 157 import org.simantics.db.procedure.SyncMultiListener;
 158 import org.simantics.db.procedure.SyncMultiProcedure;
 159 import org.simantics.db.procedure.SyncProcedure;
 160 import org.simantics.db.procedure.SyncSetListener;
 161 import org.simantics.db.request.AsyncMultiRead;
 162 import org.simantics.db.request.AsyncRead;
 163 import org.simantics.db.request.DelayedWrite;
 164 import org.simantics.db.request.DelayedWriteResult;
 165 import org.simantics.db.request.ExternalRead;
 166 import org.simantics.db.request.MultiRead;
 167 import org.simantics.db.request.Read;
 168 import org.simantics.db.request.ReadInterface;
 169 import org.simantics.db.request.RequestFlags;
 170 import org.simantics.db.request.Write;
 171 import org.simantics.db.request.WriteInterface;
 172 import org.simantics.db.request.WriteOnly;
 173 import org.simantics.db.request.WriteOnlyResult;
 174 import org.simantics.db.request.WriteResult;
 175 import org.simantics.layer0.Layer0;
 176 import org.simantics.scl.compiler.types.Type;
 177 import org.simantics.scl.compiler.types.exceptions.SCLTypeParseException;
 178 import org.simantics.scl.reflection.ReflectionUtils;
 179 import org.simantics.scl.reflection.ValueNotFoundException;
 180 import org.simantics.scl.runtime.function.Function3;
 181 import org.simantics.utils.DataContainer;
 182 import org.simantics.utils.Development;
 183 import org.simantics.utils.datastructures.Pair;
 184 import org.simantics.utils.datastructures.collections.CollectionUtils;
 185
 186 import gnu.trove.map.hash.TObjectIntHashMap;
 187
 188 public class ReadGraphImpl implements ReadGraph {
 189
 190     final static boolean EMPTY_RESOURCE_CHECK = false;
 191
 192         final public CacheEntry parent;
 193         final public QueryProcessor processor;
 194
 195         final static Binding DATA_TYPE_BINDING_INTERNAL = Bindings.getBindingUnchecked(Datatype.class);
 196         final static Serializer DATA_TYPE_SERIALIZER = Bindings.getSerializerUnchecked(DATA_TYPE_BINDING_INTERNAL);
 197
 198         final public static TObjectIntHashMap<String> counters = new TObjectIntHashMap<String>();
 199
 200         public static void resetCounters() {
 201                 counters.clear();
 202         }
 203
 204         public static String listCounters(File file) throws IOException {
 205
 206                 PrintStream b = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
 207
 208                 for(Pair<String,Integer> p : CollectionUtils.valueSortedEntries(counters)) {
 209                         b.print(-p.second + " " + p.first + "\n");
 210                 }
 211
 212                 b.close();
 213
 214                 return "Dumped " + counters.size() + " queries.";
 215
 216         }
 217
 218         /*
 219          * Implementation of the interface ReadGraph
 220          */
 221         final public String getURI(final Resource resource)     throws AssumptionException, ValidationException, ServiceException {
 222
 223                 assert (resource != null);
 224
 225                 try {
 226
 227                         return syncRequest(new org.simantics.db.common.uri.ResourceToURI(resource));
 228
 229                 } catch (AssumptionException e) {
 230
 231                         throw new AssumptionException(e);
 232
 233                 } catch (ValidationException e) {
 234
 235                         throw new ValidationException(e);
 236
 237                 } catch (ServiceException e) {
 238
 239                         throw new ServiceException(e);
 240
 241                 } catch (DatabaseException e) {
 242
 243                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 244
 245                 }
 246
 247         }
 248
 249         final public String getPossibleURI(final Resource resource)     throws ValidationException,     ServiceException {
 250
 251                 assert (resource != null);
 252
 253                 try {
 254
 255                         return syncRequest(new org.simantics.db.common.uri.ResourceToPossibleURI(resource));
 256
 257                 } catch (ValidationException e) {
 258
 259                         throw new ValidationException(e);
 260
 261                 } catch (ServiceException e) {
 262
 263                         throw new ServiceException(e);
 264
 265                 } catch (DatabaseException e) {
 266
 267                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 268
 269                 }
 270
 271         }
 272
 273         final public Resource getResource(final String id)
 274                         throws ResourceNotFoundException, ValidationException,
 275                         ServiceException {
 276
 277                 assert (id != null);
 278
 279                 try {
 280
 281                         return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
 282                                         id));
 283
 284                 } catch (ResourceNotFoundException e) {
 285
 286                         throw new ResourceNotFoundException(id, e);
 287
 288                 } catch (ValidationException e) {
 289
 290                         throw new ValidationException(e);
 291
 292                 } catch (ServiceException e) {
 293
 294                         throw new ServiceException(e);
 295
 296                 } catch (DatabaseException e) {
 297
 298                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 299
 300                 }
 301
 302         }
 303
 304         final public Resource getPossibleResource(final String id)
 305         throws ResourceNotFoundException, ValidationException,
 306         ServiceException {
 307
 308                 assert (id != null);
 309
 310                 try {
 311
 312                         return syncRequest(new org.simantics.db.common.primitiverequest.Resource(
 313                                         id));
 314
 315                 } catch (ResourceNotFoundException e) {
 316
 317                         return null;
 318
 319                 } catch (ValidationException e) {
 320
 321                         throw new ValidationException(e);
 322
 323                 } catch (ServiceException e) {
 324
 325                         throw new ServiceException(e);
 326
 327                 } catch (DatabaseException e) {
 328
 329                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 330
 331                 }
 332
 333         }
 334
 335         final public Resource getRootLibrary() {
 336                 return processor.getRootLibraryResource();
 337         }
 338
 339         final public Resource getBuiltin(final String id)
 340                         throws ResourceNotFoundException, ServiceException {
 341
 342                 assert (id != null);
 343
 344                 try {
 345
 346                         return syncRequest(new Builtin(id));
 347
 348                 } catch (ResourceNotFoundException e) {
 349
 350                         throw new ResourceNotFoundException(id, e);
 351
 352                 } catch (ServiceException e) {
 353
 354                         throw new ServiceException(e);
 355
 356                 } catch (DatabaseException e) {
 357
 358                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 359
 360                 }
 361
 362         }
 363
 364         static class StatementReadProcedure extends TIntArrayListInternal implements StatementProcedure {
 365
 366                 private static Throwable DONE = new Throwable();
 367
 368                 Throwable exception = null;
 369
 370                 final ResourceSupport support;
 371
 372                 public StatementReadProcedure(ResourceSupport support) {
 373                         this.support = support;
 374                 }
 375
 376                 @Override
 377                 public synchronized void execute(AsyncReadGraph graph, int s, int p, int o) {
 378                         add(s);
 379                         add(p);
 380                         add(o);
 381                 }
 382
 383                 @Override
 384                 public void finished(AsyncReadGraph graph) {
 385                         exception = DONE;
 386                 }
 387
 388                 @Override
 389                 public void exception(AsyncReadGraph graph, Throwable t) {
 390                         exception = t;
 391                 }
 392
 393                 public void checkAndThrow() throws DatabaseException {
 394                         if(exception != DONE) {
 395                                 if (exception instanceof DatabaseException)
 396                                         throw (DatabaseException) exception;
 397                                 else
 398                                         throw new DatabaseException(
 399                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
 400                                                         exception);
 401                         }
 402                 }
 403
 404                 public boolean done() {
 405                         return exception != null;
 406                 }
 407
 408                 @Override
 409                 public boolean contains(Object obj) {
 410                     if(!(obj instanceof InternalStatement))
 411                         return false;
 412                     InternalStatement statement = (InternalStatement)obj;
 413                     int s = statement.s;
 414                     int p = statement.p;
 415                     int o = statement.o;
 416                     for(int i=0;i<sizeInternal();i+=3)
 417                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 418                     return true;
 419                     return false;
 420                 }
 421
 422                 @SuppressWarnings("unchecked")
 423         @Override
 424                 public <T> T[] toArray(T[] a) {
 425                     int length = sizeInternal() / 3;
 426                     if(length > a.length) {
 427                         Class<?> arrayType = a.getClass();
 428                         a = (arrayType == Object[].class)
 429                                 ? (T[]) new Object[length]
 430                                 : (T[]) Array.newInstance(arrayType.getComponentType(), length);
 431                     }
 432                     else {
 433                         for(int i=length;i<a.length;++i)
 434                             a[i] = null;
 435                     }
 436             for(int i=0,j=0;i<sizeInternal();i+=3,++j)
 437                 a[j] = (T)new InternalStatement(support, getQuick(i), getQuick(i+1), getQuick(i+2));
 438             return a;
 439                 }
 440
 441                 @Override
 442                 public boolean add(Statement e) {
 443                         throw new UnsupportedOperationException();
 444                 }
 445
 446                 @Override
 447                 public boolean remove(Object o) {
 448                         throw new UnsupportedOperationException();
 449                 }
 450
 451                 @Override
 452                 public boolean addAll(Collection<? extends Statement> c) {
 453                         throw new UnsupportedOperationException();
 454                 }
 455
 456                 class IteratorImpl implements ListIterator<Statement> {
 457
 458             int index;
 459
 460             public IteratorImpl(int index) {
 461                 this.index = index;
 462             }
 463
 464             @Override
 465             public boolean hasNext() {
 466                 return index < sizeInternal();
 467             }
 468
 469             @Override
 470             public Statement next() {
 471                 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 472                 index += 3;
 473                 return result;
 474             }
 475
 476             @Override
 477             public void remove() {
 478                 throw new Error("Not supported");
 479             }
 480
 481             @Override
 482             public boolean hasPrevious() {
 483                 return index > 0;
 484             }
 485
 486             @Override
 487             public Statement previous() {
 488                 index -= 3;
 489                 Statement result = new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 490                 return result;
 491             }
 492
 493             @Override
 494             public int nextIndex() {
 495                 return index/3;
 496             }
 497
 498             @Override
 499             public int previousIndex() {
 500                 return index/3-1;
 501             }
 502
 503             @Override
 504             public void set(Statement e) {
 505                 throw new UnsupportedOperationException();
 506             }
 507
 508             @Override
 509             public void add(Statement e) {
 510                 throw new UnsupportedOperationException();
 511             }
 512
 513         };
 514
 515                 @Override
 516                 public Iterator<Statement> iterator() {
 517                         return new IteratorImpl(0);
 518                 }
 519
 520                 @Override
 521                 public int size() {
 522                         return sizeInternal() / 3;
 523                 }
 524
 525                 @Override
 526                 public Object[] toArray() {
 527                     Object[] result = new Object[sizeInternal() / 3];
 528                     for(int i=0,j=0;j<sizeInternal();i++,j+=3)
 529                         result[i] = new InternalStatement(support, getQuick(j), getQuick(j+1), getQuick(j+2));
 530                         return result;
 531                 }
 532
 533         @Override
 534         public boolean addAll(int index, Collection<? extends Statement> c) {
 535             throw new UnsupportedOperationException();
 536         }
 537
 538         @Override
 539         public Statement get(int index) {
 540             index += 3;
 541             if(index < 0 || index >= sizeInternal())
 542                 throw new IndexOutOfBoundsException();
 543             return new InternalStatement(support, getQuick(index), getQuick(index+1), getQuick(index+2));
 544         }
 545
 546         @Override
 547         public Statement set(int index, Statement element) {
 548             throw new UnsupportedOperationException();
 549         }
 550
 551         @Override
 552         public void add(int index, Statement element) {
 553             throw new UnsupportedOperationException();
 554         }
 555
 556         @Override
 557         public Statement remove(int index) {
 558             throw new UnsupportedOperationException();
 559         }
 560
 561         @Override
 562         public int indexOf(Object obj) {
 563             if(!(obj instanceof InternalStatement))
 564                 return -1;
 565             InternalStatement statement = (InternalStatement)obj;
 566             int s = statement.s;
 567             int p = statement.p;
 568             int o = statement.o;
 569             for(int i=0;i<sizeInternal();i+=3)
 570                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 571                     return i/3;
 572             return -1;
 573         }
 574
 575         @Override
 576         public int lastIndexOf(Object obj) {
 577             if(!(obj instanceof InternalStatement))
 578                 return -1;
 579             InternalStatement statement = (InternalStatement)obj;
 580             int s = statement.s;
 581             int p = statement.p;
 582             int o = statement.o;
 583             for(int i=sizeInternal()-3;i>=0;i-=3)
 584                 if(s==getQuick(i) && p==getQuick(i+1) && o==getQuick(i+2))
 585                     return i/3;
 586             return -1;
 587         }
 588
 589         @Override
 590         public ListIterator<Statement> listIterator() {
 591             return new IteratorImpl(0);
 592         }
 593
 594         @Override
 595         public ListIterator<Statement> listIterator(int index) {
 596             return new IteratorImpl(index*3);
 597         }
 598
 599         @Override
 600         public List<Statement> subList(int fromIndex, int toIndex) {
 601             if(fromIndex < 0 || toIndex*3 >= sizeInternal() || fromIndex > toIndex)
 602                 throw new IndexOutOfBoundsException();
 603             return new RandomAccessSubList<Statement>(this, fromIndex, toIndex-fromIndex);
 604         }
 605         }
 606
 607         @Override
 608         final public Collection<Statement> getStatements(final Resource subject,
 609                         final Resource relation)
 610                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 611
 612                 assert (subject != null);
 613                 assert (relation != null);
 614
 615                 try {
 616
 617                         StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
 618                         processor.forEachStatement(this, subject, relation, procedure);
 619                         procedure.checkAndThrow();
 620                         return procedure;
 621
 622                 } catch (DatabaseException e) {
 623
 624                         System.err.println(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation);
 625
 626                         StatementReadProcedure procedure = new StatementReadProcedure(getResourceSupport());
 627                         processor.forEachStatement(this, subject, relation, procedure);
 628
 629                         return Collections.emptyList();
 630
 631 //                      throw new ServiceException(INTERNAL_ERROR_STRING + " getStatements " + subject + " " + relation, e);
 632
 633                 }
 634
 635         }
 636
 637         @Override
 638         final public Collection<Statement> getAssertedStatements(final Resource subject, final Resource relation)
 639                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 640
 641                 assert (subject != null);
 642                 assert (relation != null);
 643
 644                 try {
 645
 646                         return syncRequest(new ForEachAssertedStatement(subject, relation));
 647
 648                 } catch (ManyObjectsForFunctionalRelationException e) {
 649
 650                         throw new ManyObjectsForFunctionalRelationException(e);
 651
 652                 } catch (ServiceException e) {
 653
 654                         throw new ServiceException(e);
 655
 656                 } catch (DatabaseException e) {
 657
 658                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 659
 660                 }
 661
 662         }
 663
 664         @Override
 665         final public Collection<Resource> getPredicates(final Resource subject) throws ServiceException {
 666
 667                 assert (subject != null);
 668
 669                 try {
 670
 671                         return processor.getPredicates(this, subject);
 672
 673 //                      AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 674 //                      processor.forEachPredicate(this, subject, procedure);
 675 //                      procedure.checkAndThrow();
 676 //                      return procedure;
 677
 678                 } catch (ServiceException e) {
 679
 680                         throw new ServiceException(e);
 681
 682                 } catch (DatabaseException e) {
 683
 684                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 685
 686                 }  catch (Throwable e) {
 687
 688             throw new ServiceException(e);
 689
 690                 }
 691
 692         }
 693
 694         @Override
 695         final public Collection<Resource> getPrincipalTypes(final Resource subject)
 696                         throws ServiceException {
 697
 698                 assert (subject != null);
 699
 700                 try {
 701
 702                         AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 703                         processor.forEachPrincipalType(this, subject, procedure);
 704                         procedure.checkAndThrow();
 705                         return procedure;
 706
 707                 } catch (ServiceException e) {
 708
 709                         throw new ServiceException(e);
 710
 711                 } catch (DatabaseException e) {
 712
 713                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 714
 715                 }
 716
 717         }
 718
 719         @Override
 720         final public Set<Resource> getTypes(final Resource subject) throws ServiceException {
 721
 722                 assert (subject != null);
 723
 724                 try {
 725
 726                         return processor.getTypes(this, subject);
 727
 728                 } catch (ServiceException e) {
 729
 730                         throw new ServiceException(e);
 731
 732                 } catch (DatabaseException e) {
 733
 734                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 735
 736         } catch (Throwable e) {
 737
 738             throw new ServiceException(e);
 739
 740                 }
 741
 742         }
 743
 744         @Override
 745         final public Set<Resource> getSupertypes(final Resource subject)
 746                         throws ServiceException {
 747
 748                 assert (subject != null);
 749
 750                 try {
 751
 752                         SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
 753                         processor.forSupertypes(this, subject, procedure);
 754                         procedure.checkAndThrow();
 755                         return procedure.result;
 756
 757                 } catch (ServiceException e) {
 758
 759                         throw new ServiceException(e);
 760
 761                 } catch (DatabaseException e) {
 762
 763                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 764
 765                 }
 766
 767         }
 768
 769         @Override
 770         final public Set<Resource> getSuperrelations(final Resource subject)
 771                         throws ServiceException {
 772
 773                 assert (subject != null);
 774
 775                 try {
 776
 777                         SyncReadProcedure<Set<Resource>> procedure = new SyncReadProcedure<Set<Resource>>();
 778                         processor.forSuperrelations(this, subject, procedure);
 779                         procedure.checkAndThrow();
 780                         return procedure.result;
 781
 782                 } catch (ServiceException e) {
 783
 784                         throw new ServiceException(e);
 785
 786                 } catch (DatabaseException e) {
 787
 788                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 789
 790                 }
 791
 792         }
 793
 794         @Override
 795         public Resource getPossibleSuperrelation(Resource subject) throws ServiceException {
 796
 797                 try {
 798
 799                         SyncReadProcedure<Resource> procedure = new SyncReadProcedure<Resource>();
 800                         processor.forPossibleSuperrelation(this, subject, procedure);
 801                         procedure.checkAndThrow();
 802                         return procedure.result;
 803
 804                 } catch (ServiceException e) {
 805
 806                         throw new ServiceException(e);
 807
 808                 } catch (DatabaseException e) {
 809
 810                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 811
 812                 }
 813
 814         }
 815
 816         @Override
 817         final public Collection<Resource> getObjects(final Resource subject, final Resource relation)
 818                         throws ServiceException {
 819
 820                 assert (subject != null);
 821                 assert (relation != null);
 822
 823                 if(Development.DEVELOPMENT) {
 824             if(Development.isTrue(DevelopmentKeys.READGRAPH_COUNT)) {
 825                 counters.adjustOrPutValue("objects $" + subject.getResourceId() + " $" + relation.getResourceId(), 1, 1);
 826             }
 827             //if(subject.getResourceId()==xx && relation.getResourceId()==xx) new Exception().printStackTrace();
 828                 }
 829
 830                 try {
 831
 832                         AsyncMultiReadProcedure<Resource> procedure = new AsyncMultiReadProcedure<Resource>();
 833                         processor.forEachObject(this, subject, relation, procedure);
 834                         procedure.checkAndThrow();
 835                         return procedure;
 836
 837                 } catch (DatabaseException e) {
 838
 839                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 840
 841                 }
 842
 843         }
 844
 845         @Override
 846         final public Collection<Resource> getAssertedObjects(
 847                         final Resource subject, final Resource relation)
 848                         throws ManyObjectsForFunctionalRelationException, ServiceException {
 849
 850         if (subject == null)
 851             throw new ArgumentException("Subject must not be null.");
 852         if (relation == null)
 853             throw new ArgumentException("Relation must not be null. Subject=" + subject);
 854
 855                 try {
 856
 857                         return syncRequest(new ForEachAssertedObject(subject, relation));
 858
 859                 } catch (ManyObjectsForFunctionalRelationException e) {
 860
 861                         throw new ManyObjectsForFunctionalRelationException(e);
 862
 863                 } catch (ServiceException e) {
 864
 865                         throw new ServiceException(e);
 866
 867                 } catch (DatabaseException e) {
 868
 869                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
 870
 871                 }
 872
 873         }
 874
 875         @Override
 876         final public Resource getInverse(final Resource relation) throws NoInverseException, ServiceException {
 877
 878                 assert (relation != null);
 879
 880                 try {
 881
 882                         return getSingleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
 883
 884                 } catch (NoSingleResultException e) {
 885
 886                         throw new NoInverseException(e);
 887
 888                 } catch (ServiceException e) {
 889
 890                         throw new ServiceException(e);
 891
 892                 }
 893
 894         }
 895
 896         @Override
 897         final public Resource getSingleObject(final Resource subject, final Resource relation) throws NoSingleResultException, ServiceException {
 898
 899                 if( subject == null) throw new IllegalArgumentException("subject can not be null");
 900                 if( relation == null) throw new IllegalArgumentException("relation can not be null");
 901
 902                 try {
 903                         int single = processor.getSingleObject(this, subject, relation);
 904                         if (single == 0) {
 905                                 if (EMPTY_RESOURCE_CHECK) {
 906                                         if (!hasStatement(subject)) {
 907                                                 throw new EmptyResourceException("Resource " + debugString(subject));
 908                                         }
 909                                 }
 910                                 throw new NoSingleResultException("No single object for subject " + debugString(subject)
 911                                                 + " and relation " + debugString(relation), single);
 912                         }
 913                         return processor.querySupport.getResource(single);
 914                 } catch (NoSingleResultException e) {
 915                         throw e;
 916                 } catch (DatabaseException e) {
 917                         throw new ServiceException(e);
 918                 }
 919         }
 920
 921         @Override
 922         final public Statement getSingleStatement(final Resource subject, final Resource relation) throws NoSingleResultException, ManyObjectsForFunctionalRelationException, ServiceException {
 923                 assert (subject != null);
 924                 assert (relation != null);
 925                 try {
 926                         Collection<Statement> statements = getStatements(subject, relation);
 927                         if (statements.size() == 1) {
 928                                 return statements.iterator().next();
 929                         } else {
 930                                 if (EMPTY_RESOURCE_CHECK)
 931                                         if (!hasStatement(subject))
 932                                                 throw new EmptyResourceException("Resource " + debugString(subject));
 933                                 throw new NoSingleResultException("No single statement for subject " + debugString(subject)
 934                                                 + " and relation " + debugString(relation), statements.size());
 935                         }
 936                 } catch (ServiceException e) {
 937                         throw new ServiceException(e);
 938                 }
 939         }
 940
 941         @Override
 942         final public Resource getSingleType(final Resource subject) throws NoSingleResultException, ServiceException {
 943                 assert (subject != null);
 944                 try {
 945                         ArrayList<Resource> principalTypes = (ArrayList<Resource>)getPrincipalTypes(subject);
 946                         if (principalTypes.size() == 1) {
 947                             return principalTypes.get(0);
 948                         } else {
 949                             throw new NoSingleResultException("No single type for subject " + debugString(subject), principalTypes.size());
 950                         }
 951                 } catch (ServiceException e) {
 952                         throw new ServiceException(e);
 953                 }
 954         }
 955
 956         @Override
 957         final public Resource getSingleType(final Resource subject,
 958                         final Resource baseType) throws NoSingleResultException,
 959                         ServiceException {
 960
 961                 assert (subject != null);
 962                 assert (baseType != null);
 963
 964                 try {
 965                         return syncRequest(new SingleType(subject, baseType));
 966                 } catch (DatabaseException e) {
 967                     throw new NoSingleResultException("subject=" + subject + ", baseType=" + baseType, 0, e);
 968                 }
 969         }
 970
 971         @Override
 972         final public <T> T getValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
 973
 974                 assert (subject != null);
 975
 976                 try {
 977
 978                         Layer0 L0 = processor.getL0(this);
 979             int object = processor.getSingleObject(this, subject, L0.HasDataType);
 980             if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
 981
 982             if(processor.isImmutable(object)) {
 983                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
 984                         return getValue(subject, binding);
 985             } else {
 986                     byte[] dt = processor.getValue(this, object);
 987                     if(dt == null) throw new ServiceException("No data type for " + subject);
 988                     Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
 989                     Binding binding = Bindings.getBinding(datatype);
 990                     return getValue(subject, binding);
 991             }
 992
 993         } catch (IOException e) {
 994
 995             throw new ServiceException(e);
 996
 997                 } catch (DoesNotContainValueException e) {
 998
 999                         throw new DoesNotContainValueException(e, subject);
1000
1001                 } catch (ServiceException e) {
1002
1003                         throw new ServiceException(e);
1004
1005                 } catch (DatabaseException e) {
1006
1007                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1008
1009         }
1010
1011         }
1012
1013     @Override
1014     final public Variant getVariantValue(final Resource subject) throws DoesNotContainValueException, ServiceException {
1015
1016         assert (subject != null);
1017
1018         try {
1019
1020             Layer0 L0 = processor.getL0(this);
1021             int object = processor.getSingleObject(this, subject, L0.HasDataType);
1022             if(object == 0) throw new DoesNotContainValueException("No data type for " + subject);
1023
1024             if(processor.isImmutable(object)) {
1025                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1026                 return new Variant(binding, getValue(subject, binding));
1027             } else {
1028                 byte[] dt = processor.getValue(this, object);
1029                 if(dt == null) throw new ServiceException("No data type for " + subject);
1030                 Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1031                 Binding binding = Bindings.getBinding(datatype);
1032                 return new Variant(binding, getValue(subject, binding));
1033             }
1034
1035         } catch (IOException e) {
1036
1037             throw new ServiceException(e);
1038
1039         } catch (DoesNotContainValueException e) {
1040
1041             throw new DoesNotContainValueException(e, subject);
1042
1043         } catch (ServiceException e) {
1044
1045             throw new ServiceException(e);
1046
1047         } catch (DatabaseException e) {
1048
1049             throw new ServiceException(INTERNAL_ERROR_STRING, e);
1050
1051         }
1052         }
1053
1054         static final IdentityHashMap<Binding,Serializer> serializers = new IdentityHashMap<Binding,Serializer>();
1055
1056         static {
1057                 serializers.put(Bindings.STRING, Bindings.STRING.serializer());
1058         }
1059
1060         final protected Serializer getSerializer(Binding binding) {
1061             return binding.serializer();
1062         }
1063
1064         @Override
1065         final public <T> T getValue(final Resource subject, final Binding binding) throws DoesNotContainValueException, BindingException,
1066                         ServiceException {
1067
1068                 assert (subject != null);
1069
1070                 try {
1071
1072                         byte[] bytes = processor.getValue(this, subject);
1073                         if (bytes == null) throw new DoesNotContainValueException("No value for resource " + subject);
1074
1075                         Serializer serializer = getSerializer(binding);
1076                         return (T)serializer.deserialize(bytes);
1077
1078                 } catch (DoesNotContainValueException e) {
1079
1080                         throw new DoesNotContainValueException(e);
1081
1082                 } catch (IOException e) {
1083
1084                         throw new ServiceException(e);
1085
1086                 } catch (DatabaseException e) {
1087
1088             throw new ServiceException(e);
1089
1090         } catch (BufferUnderflowException e) {
1091             // This is sometimes thrown when deserialize fails because wrong format.
1092             // For callers of this method this is just an service exception.
1093             throw new ServiceException(e);
1094         }
1095
1096         }
1097
1098         @Override
1099         final public <T> T getRelatedValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1100                         DoesNotContainValueException, ServiceException {
1101
1102                 assert (subject != null);
1103                 assert (relation != null);
1104
1105                 try {
1106                         Resource object = getSingleObject(subject, relation);
1107                         return getValue(object);
1108                 } catch (NoSingleResultException e) {
1109                         throw new NoSingleResultException("No single value found for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1110                 } catch (DoesNotContainValueException e) {
1111                         try {
1112                                 Layer0 L0 = processor.getL0(this);
1113                                 Resource object = getPossibleObject(subject, relation);
1114                                 if(isInstanceOf(object, L0.Value)) {
1115                                         if(isInstanceOf(object, L0.Literal)) {
1116                                                 throw new DoesNotContainValueException(e);
1117                                         } else {
1118                                                 throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1119                                         }
1120                                 } else {
1121                                         throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1122                                 }
1123                         } catch (DoesNotContainValueException e2) {
1124                                 throw e2;
1125                         } catch (DatabaseException e2) {
1126                                 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1127                         }
1128                 } catch (ServiceException e) {
1129                         throw new ServiceException(e);
1130                 }
1131         }
1132
1133     @Override
1134     final public Variant getRelatedVariantValue(final Resource subject, final Resource relation) throws NoSingleResultException,
1135             DoesNotContainValueException, ServiceException {
1136
1137         assert (subject != null);
1138         assert (relation != null);
1139
1140         try {
1141             Resource object = getSingleObject(subject, relation);
1142             return getVariantValue(object);
1143         } catch (NoSingleResultException e) {
1144             throw new NoSingleResultException("No single object for subject " + debugString(subject) + " and relation " + debugString(relation), e.getResultCount(), e);
1145         } catch (DoesNotContainValueException e) {
1146             try {
1147                 Layer0 L0 = processor.getL0(this);
1148                 Resource object = getPossibleObject(subject, relation);
1149                 if(isInstanceOf(object, L0.Value)) {
1150                     if(isInstanceOf(object, L0.Literal)) {
1151                         throw new DoesNotContainValueException(e);
1152                     } else {
1153                         throw new InvalidLiteralException("The object " + object + " is not an instance of L0.Literal (use getRelatedValue2 instead)", e);
1154                     }
1155                 } else {
1156                     throw new DoesNotContainValueException("The object " + object + " is not an instance of L0.Value", e);
1157                 }
1158             } catch (DoesNotContainValueException e2) {
1159                 throw e2;
1160             } catch (DatabaseException e2) {
1161                 throw new InternalException("The client failed to analyse the cause of the following exception", e);
1162             }
1163         } catch (ServiceException e) {
1164             throw new ServiceException(e);
1165         }
1166     }
1167
1168         @Override
1169         final public <T> T getRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1170                         throws NoSingleResultException, DoesNotContainValueException, BindingException, ServiceException {
1171
1172                 assert (subject != null);
1173                 assert (relation != null);
1174
1175                 try {
1176                         Resource object = getSingleObject(subject, relation);
1177                         return getValue(object, binding);
1178                 } catch (NoSingleResultException e) {
1179                     String message = "";
1180                     try {
1181                     String subjectName = NameUtils.getSafeName(this, subject, true);
1182                     String relationName = NameUtils.getSafeName(this, relation, true);
1183                     message = "Subject: " + subjectName + ", Relation: " + relationName;
1184                     } catch (DatabaseException e2) {
1185
1186                     }
1187             throw new NoSingleResultException(message, e.getResultCount(), e);
1188                 } catch (DoesNotContainValueException e) {
1189                         throw new DoesNotContainValueException(e);
1190                 } catch (ServiceException e) {
1191                         throw new ServiceException(e);
1192                 }
1193         }
1194
1195         @Override
1196         final public <T> T adapt(final Resource resource, final Class<T> clazz)
1197                         throws AdaptionException, ValidationException, ServiceException {
1198
1199                 assert (resource != null);
1200                 assert (clazz != null);
1201
1202                 try {
1203
1204                         return syncRequest(new Adapter<T>(resource, clazz));
1205
1206                 } catch (AdaptionException e) {
1207
1208                         throw new AdaptionException(e);
1209
1210                 } catch (ValidationException e) {
1211
1212                         throw new ValidationException(e);
1213
1214                 } catch (ServiceException e) {
1215
1216                         throw new ServiceException(e);
1217
1218                 } catch (DatabaseException e) {
1219
1220                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1221
1222                 }
1223
1224         }
1225
1226         @Override
1227         final public <T,C> T adaptContextual(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1228                         throws AdaptionException, ValidationException, ServiceException {
1229
1230                 assert (resource != null);
1231                 assert (context != null);
1232
1233                 class ContextualAdapter implements AsyncRead<T> {
1234
1235                         final private Resource resource;
1236                         final private C context;
1237                     final private Class<T> clazz;
1238
1239                     @Override
1240                     public int hashCode() {
1241                         return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1242                     }
1243
1244                     @Override
1245                     final public int threadHash() {
1246                         return resource.getThreadHash();
1247                     }
1248
1249                     @Override
1250                     public boolean equals(Object object) {
1251                         if (this == object)
1252                             return true;
1253                         else if (object == null)
1254                             return false;
1255                         else if (getClass() != object.getClass())
1256                             return false;
1257                         ContextualAdapter r = (ContextualAdapter)object;
1258                         return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1259                     }
1260
1261                     @Override
1262                     public int getFlags() {
1263                         return 0;
1264                     }
1265
1266                     public ContextualAdapter(Resource resource, C context, Class<T> clazz) {
1267                         this.resource = resource;
1268                         this.context = context;
1269                         this.clazz = clazz;
1270                     }
1271
1272                     @Override
1273                     public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1274
1275                                 final AdaptionService service = getSession().peekService(AdaptionService.class);
1276                                 if (service == null)
1277                                         procedure.exception(graph, new ServiceException("No AdaptionService available"));
1278                                 else
1279                                         service.adapt(graph, resource, context, contextClass, clazz, false, procedure);
1280
1281                     }
1282
1283                     @Override
1284                     public String toString() {
1285                         return "Adapter for (" + resource + "," + context + ") as " + clazz.getName();
1286                     }
1287
1288                 }
1289
1290                 try {
1291
1292                         return syncRequest(new ContextualAdapter(resource, context, clazz));
1293
1294                 } catch (AdaptionException e) {
1295
1296                         throw new AdaptionException(e);
1297
1298                 } catch (ValidationException e) {
1299
1300                         throw new ValidationException(e);
1301
1302                 } catch (ServiceException e) {
1303
1304                         throw new ServiceException(e);
1305
1306                 } catch (DatabaseException e) {
1307
1308                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1309
1310                 }
1311
1312         }
1313
1314         @Override
1315         final public <T> T adaptRelated(final Resource resource, final Resource relation, final Class<T> clazz)
1316                         throws AdaptionException, NoSingleResultException, ValidationException, ServiceException {
1317
1318                 assert (resource != null);
1319                 assert (clazz != null);
1320
1321                 Statement stm = getSingleStatement(resource, relation);
1322
1323                 return adaptContextual(stm.getObject(), new RelationContextImpl(resource, stm), RelationContext.class, clazz);
1324
1325         }
1326
1327         @Override
1328         final public <T> T getPossibleRelatedAdapter(final Resource resource, final Resource relation, final Class<T> clazz)
1329                         throws ValidationException, ServiceException {
1330
1331                 try {
1332                         return adaptRelated(resource, relation, clazz);
1333                 } catch (DatabaseException e) {
1334                         return null;
1335                 }
1336
1337         }
1338
1339         @Override
1340         final public <T,C> T getPossibleContextualAdapter(final Resource resource, final C context, final Class<C> contextClass, final Class<T> clazz)
1341                         throws ValidationException, ServiceException {
1342
1343                 assert (resource != null);
1344                 assert (context != null);
1345
1346                 class PossibleContextualAdapter implements AsyncRead<T> {
1347
1348                         final private Resource resource;
1349                         final private C context;
1350                     final private Class<T> clazz;
1351
1352                     @Override
1353                     public int hashCode() {
1354                         return resource.hashCode() + 31 * (clazz.hashCode() + 41 * context.hashCode());
1355                     }
1356
1357                     @Override
1358                     final public int threadHash() {
1359                         return resource.getThreadHash();
1360                     }
1361
1362                     @Override
1363                     public boolean equals(Object object) {
1364                         if (this == object)
1365                             return true;
1366                         else if (object == null)
1367                             return false;
1368                         else if (getClass() != object.getClass())
1369                             return false;
1370                         PossibleContextualAdapter r = (PossibleContextualAdapter)object;
1371                         return resource.equals(r.resource) && context.equals(r.context) && clazz.equals(r.clazz);
1372                     }
1373
1374                     @Override
1375                     public int getFlags() {
1376                         return 0;
1377                     }
1378
1379                     public PossibleContextualAdapter(Resource resource, C context, Class<T> clazz) {
1380                         this.resource = resource;
1381                         this.context = context;
1382                         this.clazz = clazz;
1383                     }
1384
1385                     @Override
1386                     public void perform(AsyncReadGraph graph, AsyncProcedure<T> procedure) {
1387
1388                                 final AdaptionService service = getSession().peekService(AdaptionService.class);
1389                                 if (service == null)
1390                                         procedure.exception(graph, new ServiceException("No AdaptionService available"));
1391                                 else
1392                                         service.adapt(graph, resource, context, contextClass, clazz, true, procedure);
1393
1394                     }
1395
1396                     @Override
1397                     public String toString() {
1398                         return "Possible adapter for (" + resource + "," + context + ") as " + clazz.getName();
1399                     }
1400
1401                 }
1402
1403                 try {
1404
1405                         return syncRequest(new PossibleContextualAdapter(resource, context, clazz));
1406
1407                 } catch (ValidationException e) {
1408
1409                         throw new ValidationException(e);
1410
1411                 } catch (ServiceException e) {
1412
1413                         throw new ServiceException(e);
1414
1415                 } catch (DatabaseException e) {
1416
1417                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1418
1419                 }
1420
1421         }
1422
1423         @Override
1424         final public <T> T adaptUnique(final Resource resource, final Class<T> clazz)
1425                         throws AdaptionException, ValidationException, ServiceException {
1426
1427                 assert (resource != null);
1428                 assert (clazz != null);
1429
1430                 try {
1431
1432                         return syncRequest(new UniqueAdapter<T>(resource, clazz));
1433
1434                 } catch (AdaptionException e) {
1435
1436                         throw new AdaptionException(e);
1437
1438                 } catch (ValidationException e) {
1439
1440                         throw new ValidationException(e);
1441
1442                 } catch (ServiceException e) {
1443
1444                         throw new ServiceException(e);
1445
1446                 } catch (DatabaseException e) {
1447
1448                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1449
1450                 }
1451
1452         }
1453
1454         @Override
1455         final public Resource getPossibleInverse(final Resource relation)
1456                         throws ServiceException {
1457
1458                 assert (relation != null);
1459
1460                 try {
1461
1462                         return getPossibleObject(relation, processor.querySupport.getResource(processor.getInverseOf()));
1463
1464                 } catch (ServiceException e) {
1465
1466                         throw new ServiceException(e);
1467
1468                 } catch (DatabaseException e) {
1469
1470                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1471
1472                 }
1473
1474         }
1475
1476         @Override
1477         public Resource getPossibleObject(final Resource subject, final Resource relation)
1478                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1479
1480                 assert (subject != null);
1481                 assert (relation != null);
1482
1483                 try {
1484
1485                     int result = processor.getSingleObject(this, subject, relation);
1486                     if(result == 0) return null;
1487
1488                     return processor.querySupport.getResource(result);
1489
1490              } catch (ManyObjectsForFunctionalRelationException e) {
1491
1492                  throw new ManyObjectsForFunctionalRelationException("subject=" + subject + ", relation=" + relation, e);
1493
1494                 } catch (DatabaseException e) {
1495
1496                         throw new ServiceException(e);
1497
1498                 }
1499
1500         }
1501
1502         @Override
1503         final public Statement getPossibleStatement(final Resource subject, final Resource relation)
1504                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1505
1506                 assert (subject != null);
1507                 assert (relation != null);
1508
1509                 try {
1510
1511                         Collection<Statement> statements = getStatements(subject, relation);
1512                         if(statements.size() == 1) return statements.iterator().next();
1513                         else return null;
1514
1515                 } catch (ManyObjectsForFunctionalRelationException e) {
1516
1517                         throw new ManyObjectsForFunctionalRelationException("Many objects in " + subject + " for functional relation " + relation);
1518
1519                 } catch (ServiceException e) {
1520
1521                         throw new ServiceException(e);
1522
1523                 }
1524
1525         }
1526
1527         @Override
1528         final public Resource getPossibleType(final Resource subject, final Resource baseType) throws ServiceException {
1529
1530                 assert (subject != null);
1531                 assert (baseType != null);
1532
1533                 try {
1534
1535                         AsyncReadProcedure<Resource> procedure = new AsyncReadProcedure<Resource>();
1536                         forPossibleType(subject, baseType, procedure);
1537                         procedure.checkAndThrow();
1538                         return procedure.result;
1539
1540                 } catch (ServiceException e) {
1541
1542                         throw new ServiceException(e);
1543
1544                 } catch (DatabaseException e) {
1545
1546                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1547
1548                 }
1549
1550         }
1551
1552         @Override
1553         final public <T> T getPossibleValue(final Resource subject) throws ServiceException {
1554
1555                 assert (subject != null);
1556
1557                 try {
1558
1559                     int object = processor.getSingleObject(this, subject, processor.getL0(this).HasDataType);
1560                     if(object == 0) return null;
1561
1562             if(processor.isImmutable(object)) {
1563                 Binding binding = syncRequest(new DatatypeBinding(processor.querySupport.getResource(object)), TransientCacheListener.<Binding>instance());
1564                         return getPossibleValue(subject, binding);
1565             } else {
1566                     byte[] dt = processor.getValue(this, object);
1567                     if(dt == null) return null;
1568                     Datatype datatype = (Datatype)DATA_TYPE_SERIALIZER.deserialize(dt);
1569                     Binding binding = Bindings.getBinding(datatype);
1570                     return getPossibleValue(subject, binding);
1571             }
1572
1573         } catch (IOException e) {
1574
1575             throw new ServiceException(e);
1576
1577                 } catch (ServiceException e) {
1578
1579                         throw new ServiceException(e);
1580
1581                 } catch (DatabaseException e) {
1582
1583                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1584
1585         }
1586
1587         }
1588
1589         @Override
1590         final public <T> T getPossibleValue(final Resource subject, final Binding binding) throws BindingException, ServiceException {
1591
1592                 assert (subject != null);
1593                 assert (binding != null);
1594
1595                 try {
1596
1597             byte[] dt = processor.getValue(this, subject);
1598             if(dt == null) return null;
1599                         Serializer serializer = getSerializer(binding);
1600             return (T)serializer.deserialize(dt);
1601
1602         } catch (IOException e) {
1603
1604             throw new ServiceException(e);
1605
1606                 } catch (BindingException e) {
1607
1608                         throw new BindingException(e);
1609
1610                 } catch (ServiceException e) {
1611
1612                         throw new ServiceException(e);
1613
1614                 } catch (DatabaseException e) {
1615                         e.printStackTrace();
1616                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1617         }
1618
1619         }
1620
1621         @Override
1622         public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation)
1623                         throws ManyObjectsForFunctionalRelationException, ServiceException {
1624
1625                 assert (subject != null);
1626                 assert (relation != null);
1627
1628                 try {
1629
1630                         Resource object = getPossibleObject(subject, relation);
1631                         if(object == null) return null;
1632                         else return getPossibleValue(object);
1633
1634                 } catch (ManyObjectsForFunctionalRelationException e) {
1635
1636                         throw new ManyObjectsForFunctionalRelationException(e);
1637
1638                 } catch (ServiceException e) {
1639
1640                         throw new ServiceException(e);
1641
1642                 }
1643
1644         }
1645
1646         @Override
1647         public <T> T getPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding)
1648                         throws ManyObjectsForFunctionalRelationException, BindingException, ServiceException {
1649
1650                 assert (subject != null);
1651                 assert (relation != null);
1652                 assert (binding != null);
1653
1654                 try {
1655
1656                         Resource object = getPossibleObject(subject, relation);
1657                         if(object == null) return null;
1658                         else return getPossibleValue(object, binding);
1659
1660                 } catch (ManyObjectsForFunctionalRelationException e) {
1661
1662                         throw new ManyObjectsForFunctionalRelationException(e);
1663
1664                 } catch (BindingException e) {
1665
1666                         throw new BindingException(e);
1667
1668                 } catch (ServiceException e) {
1669
1670                         throw new ServiceException(e);
1671
1672                 }
1673
1674         }
1675
1676         @Override
1677         public <T> T getPossibleAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1678
1679                 assert (resource != null);
1680                 assert (clazz != null);
1681
1682                 try {
1683
1684                         return syncRequest(new PossibleAdapter<T>(resource, clazz));
1685
1686                 } catch (ValidationException e) {
1687
1688                         throw new ValidationException(e);
1689
1690                 } catch (AdaptionException e) {
1691
1692                         return null;
1693
1694                 } catch (DatabaseException e) {
1695
1696                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1697
1698                 }
1699         }
1700
1701         @Override
1702         public <T> T getPossibleUniqueAdapter(Resource resource, Class<T> clazz) throws ValidationException, ServiceException {
1703
1704                 assert (resource != null);
1705                 assert (clazz != null);
1706
1707                 try {
1708
1709                         return syncRequest(new PossibleUniqueAdapter<T>(resource, clazz));
1710
1711                 } catch (AdaptionException e) {
1712
1713                         return null;
1714
1715                 } catch (ValidationException e) {
1716
1717                         throw new ValidationException(e);
1718
1719                 } catch (DatabaseException e) {
1720
1721                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1722
1723                 }
1724
1725         }
1726
1727     @Override
1728     final public boolean isInstanceOf(final Resource resource, final Resource type) throws ServiceException {
1729
1730         assert (resource != null);
1731         assert (type != null);
1732
1733         Set<Resource> resources = getTypes(resource);
1734         // This check was necessary because some of the callers of this method got stuck when the NPE was thrown from here.
1735         if (null == resources)
1736             return false;
1737
1738         if(EMPTY_RESOURCE_CHECK) {
1739             if (resources.isEmpty()) {
1740                 if(!hasStatement(resource)) throw new EmptyResourceException("Resource " + debugString(resource));
1741             }
1742         }
1743
1744         return resources.contains(type);
1745
1746     }
1747
1748         @Override
1749         final public boolean isInheritedFrom(final Resource resource, final Resource type) throws ServiceException {
1750
1751                 assert (resource != null);
1752                 assert (type != null);
1753
1754                 try {
1755
1756                         if(resource.equals(type)) return true;
1757
1758                         return getSupertypes(resource).contains(type);
1759
1760                 } catch (ServiceException e) {
1761
1762                         throw new ServiceException(e);
1763
1764                 }
1765
1766         }
1767
1768         @Override
1769         final public boolean isSubrelationOf(final Resource resource, final Resource type) throws ServiceException {
1770
1771                 assert (resource != null);
1772                 assert (type != null);
1773
1774                 try {
1775
1776                         if(resource.equals(type)) return true;
1777
1778                         return getSuperrelations(resource).contains(type);
1779
1780                 } catch (ServiceException e) {
1781
1782                         throw new ServiceException(e);
1783
1784                 }
1785
1786         }
1787
1788         @Override
1789         final public boolean hasStatement(final Resource subject) throws ServiceException {
1790
1791                 assert (subject != null);
1792
1793                 try {
1794
1795                         SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1796                         processor.forHasStatement(this, subject, procedure);
1797                         procedure.checkAndThrow();
1798                         return procedure.result;
1799
1800                 } catch (ServiceException e) {
1801
1802                         throw new ServiceException(e);
1803
1804                 } catch (DatabaseException e) {
1805
1806                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1807
1808                 }
1809
1810         }
1811
1812         @Override
1813         final public boolean hasStatement(final Resource subject, final Resource relation) throws ServiceException {
1814
1815                 assert (subject != null);
1816                 assert (relation != null);
1817
1818                 try {
1819
1820                         Collection<Resource> objects = getObjects(subject, relation);
1821                         return !objects.isEmpty();
1822
1823                 } catch (ServiceException e) {
1824
1825                         throw new ServiceException(e);
1826
1827                 }
1828
1829         }
1830
1831         @Override
1832         final public boolean hasStatement(final Resource subject, final Resource relation, final Resource object) throws ServiceException {
1833
1834                 assert (subject != null);
1835                 assert (relation != null);
1836                 assert (object != null);
1837
1838                 try {
1839
1840                         for(Resource o : getObjects(subject, relation)) {
1841                                 if(object.equals(o)) return true;
1842                         }
1843
1844                         return false;
1845
1846                 } catch (ServiceException e) {
1847
1848                         throw new ServiceException(e);
1849
1850                 }
1851
1852         }
1853
1854         @Override
1855         final public boolean hasValue(final Resource subject) throws ServiceException {
1856
1857                 assert (subject != null);
1858
1859                 try {
1860
1861                         SyncReadProcedure<Boolean> procedure = new SyncReadProcedure<Boolean>();
1862                         processor.forHasValue(this, subject, procedure);
1863                         procedure.checkAndThrow();
1864                         return procedure.result;
1865
1866                 } catch (ServiceException e) {
1867
1868                         throw new ServiceException(e);
1869
1870                 } catch (DatabaseException e) {
1871
1872                         throw new ServiceException(INTERNAL_ERROR_STRING, e);
1873
1874                 }
1875
1876         }
1877
1878         final AsyncProcedure<?> NONE = new AsyncProcedure<Object>() {
1879
1880                 @Override
1881                 public void execute(AsyncReadGraph graph, Object result) {
1882                 }
1883
1884                 @Override
1885                 public void exception(AsyncReadGraph graph, Throwable throwable) {
1886                 }
1887
1888         };
1889
1890         /*
1891          * Implementation of the interface RequestProcessor
1892          */
1893
1894         @Override
1895         public <T> T syncRequest(final Read<T> request) throws DatabaseException {
1896
1897                 assert (request != null);
1898
1899                 if (parent != null) {
1900
1901                         try {
1902                                 return processor.queryRead(this, request, parent, null, null);
1903                         } catch (Throwable e) {
1904                                 if(e instanceof DatabaseException) throw (DatabaseException)e;
1905                                 else throw new DatabaseException(e);
1906                         }
1907
1908                 } else {
1909
1910                         try {
1911
1912                                 return processor.tryQuery(this, request);
1913
1914                         } catch (Throwable throwable) {
1915
1916                                 //Logger.defaultLogError("Internal read request failure", throwable);
1917
1918                                 if (throwable instanceof DatabaseException)
1919                                         throw (DatabaseException) throwable;
1920                                 else
1921                                         throw new DatabaseException(
1922                                                         "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1923                                                         throwable);
1924
1925                         }
1926
1927                 }
1928
1929         }
1930
1931         @Override
1932         public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1933                         throws DatabaseException {
1934                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1935         }
1936
1937         @Override
1938         public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1939                         throws DatabaseException {
1940                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1941         }
1942
1943         @Override
1944         public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1945
1946                 assert (request != null);
1947
1948                 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1949
1950                 if (parent != null || listener != null) {
1951
1952                         try {
1953                 return processor.queryRead(this, request, parent, procedure, listener);
1954             } catch (Throwable e) {
1955                 if(e instanceof DatabaseException) throw (DatabaseException)e;
1956                 else throw new DatabaseException(e);
1957             }
1958
1959                 } else {
1960
1961                         try {
1962
1963                                 T t = processor.tryQuery(this, request);
1964                                 if(procedure != null)
1965                                         procedure.execute(this, t);
1966
1967                                 return t;
1968
1969                         } catch (Throwable throwable) {
1970
1971                                 Logger.defaultLogError("Internal read request failure", throwable);
1972
1973                                 if(procedure != null)
1974                                         procedure.exception(this, throwable);
1975
1976                                 if (throwable instanceof DatabaseException)
1977                                         throw (DatabaseException) throwable;
1978                                 else
1979                                         throw new DatabaseException(
1980                                                         "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1981                                                         throwable);
1982
1983                         }
1984
1985                 }
1986
1987         }
1988
1989         @Override
1990         public <T> T syncRequest(final Read<T> request,
1991                         final SyncProcedure<T> procedure) throws DatabaseException {
1992                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
1993         }
1994
1995         @Override
1996         public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
1997                         throws DatabaseException {
1998                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
1999         }
2000
2001         static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2002
2003                 private static Throwable DONE = new Throwable();
2004
2005                 T result = null;
2006                 Throwable exception = null;
2007
2008                 @Override
2009                 public void execute(AsyncReadGraph graph, T t) {
2010                         result = t;
2011                         exception = DONE;
2012                 }
2013
2014                 @Override
2015                 public void exception(AsyncReadGraph graph, Throwable t) {
2016                         exception = t;
2017                 }
2018
2019                 public void checkAndThrow() throws DatabaseException {
2020                         if(exception != DONE) {
2021                                 if (exception instanceof DatabaseException)
2022                                         throw (DatabaseException) exception;
2023                                 else
2024                                         throw new DatabaseException(
2025                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2026                                                         exception);
2027                         }
2028                 }
2029
2030                 public boolean done() {
2031                         return exception != null;
2032                 }
2033
2034         }
2035
2036         @Override
2037         public <T> T syncRequest(final AsyncRead<T> request)
2038                         throws DatabaseException {
2039
2040                 assert (request != null);
2041                 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2042                 syncRequest(request, procedure);
2043                 procedure.checkAndThrow();
2044                 return procedure.result;
2045
2046 //              return syncRequest(request, new AsyncProcedureAdapter<T>());
2047
2048         }
2049
2050         @Override
2051         public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2052                         throws DatabaseException {
2053                 return syncRequest(request, (AsyncProcedure<T>) procedure);
2054         }
2055
2056         @Override
2057         public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2058                         throws DatabaseException {
2059                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2060         }
2061
2062         @Override
2063         public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2064                         throws DatabaseException {
2065                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2066         }
2067
2068         @Override
2069         final public <T> T syncRequest(final AsyncRead<T> request,
2070                         final AsyncProcedure<T> procedure) throws DatabaseException {
2071
2072                 assert (request != null);
2073
2074                 // System.out.println("syncRequest " + request + " syncParent=" +
2075                 // syncParent);
2076
2077                 ListenerBase listener = getListenerBase(procedure);
2078
2079                 if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2080
2081 //                      Object syncParent = request;
2082
2083 //                      final ReadGraphImpl newGraph = newSync();
2084
2085                         final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2086                                         procedure, request);
2087
2088                         processor.query(this, request, parent, wrapper, listener);
2089
2090 //                      newGraph.waitAsync(syncParent);
2091
2092                         Throwable e = wrapper.getException();
2093                         if (e != null) {
2094                                 // The request was async - produce meaningful stack trace by
2095                                 // wrapping
2096                                 if (e instanceof DatabaseException)
2097                                         throw (DatabaseException) e;
2098                                 else
2099                                         throw new DatabaseException(e);
2100                         }
2101
2102                         return wrapper.getResult();
2103
2104                 } else {
2105
2106                         // System.out.println("direct call " + request );
2107
2108                         // Do not set the sync state.parent for external threads
2109 //                      Object syncParent = request;
2110
2111 //                      final ReadGraphImpl newGraph = newSync();
2112
2113                         final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2114                                         procedure, request);
2115
2116                         try {
2117
2118                                 processor.tryQuery(this, request, wrapper);
2119
2120                         } catch (Throwable t) {
2121
2122                                 wrapper.exception(this, t);
2123
2124                         }
2125
2126                         Throwable e = wrapper.getException();
2127                         if (e != null) {
2128                                 // The request was async - produce meaningful stack trace by
2129                                 // wrapping
2130                                 if (e instanceof DatabaseException)
2131                                         throw (DatabaseException) e;
2132                                 else
2133                                         throw new DatabaseException(e);
2134                         }
2135
2136                         return wrapper.getResult();
2137
2138                 }
2139
2140         }
2141
2142         final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2143
2144                 assert (request != null);
2145
2146                 // System.out.println("syncRequest " + request + " syncParent=" +
2147                 // syncParent);
2148
2149                 ListenerBase listener = getListenerBase(procedure);
2150
2151                 if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2152
2153 //                      final ReadGraphImpl newGraph = newSync();
2154
2155                         final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2156                                         procedure, request);
2157
2158                         processor.query(this, request, parent, wrapper, listener);
2159
2160                 } else {
2161
2162                         try {
2163
2164 //                              final ReadGraphImpl newGraph = newSync();
2165                                 processor.tryQuery(this, request, procedure);
2166 //                              newGraph.waitAsync(null);
2167                                 waitAsyncProcedure(procedure);
2168
2169                         } catch (Throwable t) {
2170                                 if(Development.DEVELOPMENT) {
2171                                         if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
2172                                         t.printStackTrace();
2173                                         }
2174                                 }
2175                                 procedure.exception(this, t);
2176                                 waitAsyncProcedure(procedure);
2177                         }
2178
2179                 }
2180
2181         }
2182
2183         @Override
2184         public <T> T syncRequest(AsyncRead<T> request,
2185                         final SyncProcedure<T> procedure) throws DatabaseException {
2186                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2187         }
2188
2189         @Override
2190         final public <T> T syncRequest(final AsyncRead<T> request,
2191                         final Procedure<T> procedure) throws DatabaseException {
2192                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2193         }
2194
2195         @Override
2196         public <T> Collection<T> syncRequest(final MultiRead<T> request)
2197                         throws DatabaseException {
2198
2199                 assert (request != null);
2200
2201                 final ArrayList<T> result = new ArrayList<T>();
2202                 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2203
2204                 syncRequest(request, new AsyncMultiProcedure<T>() {
2205
2206                         @Override
2207                         public void execute(AsyncReadGraph graph, T t) {
2208                                 synchronized (result) {
2209                                         result.add(t);
2210                                 }
2211                         }
2212
2213                         @Override
2214                         public void finished(AsyncReadGraph graph) {
2215                         }
2216
2217                         @Override
2218                         public void exception(AsyncReadGraph graph, Throwable t) {
2219                                 exception.set(t);
2220                         }
2221
2222                         @Override
2223                         public String toString() {
2224                                 return "syncRequest(MultiRead) -> " + request;
2225                         }
2226
2227                 });
2228
2229                 Throwable t = exception.get();
2230                 if (t != null) {
2231                         if (t instanceof DatabaseException)
2232                                 throw (DatabaseException) t;
2233                         else
2234                                 throw new DatabaseException(
2235                                                 "Unexpected exception in ReadGraph.syncRequest(Read)",
2236                                                 t);
2237                 }
2238
2239                 return result;
2240
2241         }
2242
2243         @Override
2244         public <T> Collection<T> syncRequest(MultiRead<T> request,
2245                         AsyncMultiListener<T> procedure) {
2246                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2247         }
2248
2249         @Override
2250         public <T> Collection<T> syncRequest(MultiRead<T> request,
2251                         SyncMultiListener<T> procedure) {
2252                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2253         }
2254
2255         @Override
2256         public <T> Collection<T> syncRequest(MultiRead<T> request,
2257                         MultiListener<T> procedure) {
2258                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2259         }
2260
2261         @Override
2262         public <T> Collection<T> syncRequest(MultiRead<T> request,
2263                         AsyncMultiProcedure<T> procedure) {
2264
2265                 assert (request != null);
2266
2267                 ListenerBase listener = getListenerBase(procedure);
2268
2269                 if (parent != null || listener != null) {
2270
2271 //                      Object syncParent = request;
2272
2273 //                      final ReadGraphImpl newGraph = newSync();
2274
2275                         processor.query(this, request, parent, procedure, listener);
2276
2277 //                      newGraph.waitAsync(syncParent);
2278
2279                 } else {
2280
2281 //                      Object syncParent = request;
2282
2283 //                      final ReadGraphImpl newGraph = newSync();
2284
2285                         final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2286
2287                         try {
2288
2289                                 request.perform(this, wrapper);
2290
2291                         } catch (Throwable t) {
2292
2293                                 wrapper.exception(this, t);
2294 //                              newGraph.waitAsync(syncParent);
2295
2296                         }
2297
2298                 }
2299
2300                 // TODO
2301                 return null;
2302
2303         }
2304
2305         @Override
2306         public <T> Collection<T> syncRequest(MultiRead<T> request,
2307                         SyncMultiProcedure<T> procedure) {
2308                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2309         }
2310
2311         @Override
2312         public <T> Collection<T> syncRequest(MultiRead<T> request,
2313                         MultiProcedure<T> procedure) {
2314                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2315         }
2316
2317         static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2318
2319                 private static Throwable DONE = new Throwable();
2320
2321                 private static final long serialVersionUID = -6494230465108115812L;
2322
2323                 Throwable exception = null;
2324
2325                 @Override
2326                 public synchronized void execute(AsyncReadGraph graph, T t) {
2327                         add(t);
2328                 }
2329
2330                 @Override
2331                 public void finished(AsyncReadGraph graph) {
2332                         exception = DONE;
2333                 }
2334
2335                 @Override
2336                 public void exception(AsyncReadGraph graph, Throwable t) {
2337                         exception = t;
2338                 }
2339
2340                 public void checkAndThrow() throws DatabaseException {
2341                         if(exception != DONE) {
2342                                 if (exception instanceof DatabaseException)
2343                                         throw (DatabaseException) exception;
2344                                 else
2345                                         throw new DatabaseException(
2346                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2347                                                         exception);
2348                         }
2349                 }
2350
2351                 public boolean done() {
2352                         return exception != null;
2353                 }
2354
2355         }
2356
2357         @Override
2358         final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2359                         throws DatabaseException {
2360
2361                 assert (request != null);
2362
2363                 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2364
2365                 syncRequest(request, procedure);
2366
2367                 procedure.checkAndThrow();
2368                 return procedure;
2369
2370         }
2371
2372         @Override
2373         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2374                         AsyncMultiListener<T> procedure) {
2375                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2376         }
2377
2378         @Override
2379         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2380                         SyncMultiListener<T> procedure) {
2381                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2382         }
2383
2384         @Override
2385         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2386                         MultiListener<T> procedure) {
2387                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2388         }
2389
2390         final private <T> void syncRequest(final AsyncMultiRead<T> request,
2391                         final AsyncMultiReadProcedure<T> procedure) {
2392
2393                 assert (request != null);
2394                 assert (procedure != null);
2395
2396                 ListenerBase listener = getListenerBase(procedure);
2397
2398                 if (parent != null || listener != null) {
2399
2400 //                      Object syncParent = request;
2401
2402 //                      final ReadGraphImpl newGraph = newSync();
2403
2404                         processor.query(this, request, parent, procedure, listener);
2405
2406 //                      newGraph.waitAsync(syncParent);
2407                         waitAsyncProcedure(procedure);
2408
2409                 } else {
2410
2411 //                      Object syncParent = callerThread == Integer.MIN_VALUE ? null
2412 //                                      : request;
2413 //
2414 //                      final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2415
2416                         try {
2417
2418 //                              inc();
2419 //                              ReadGraphImpl sync = newSync();
2420                                 request.perform(this, procedure);
2421 //                              sync.waitAsync(null);
2422                                 waitAsyncProcedure(procedure);
2423 //                              dec();
2424
2425                         } catch (Throwable t) {
2426
2427                                 waitAsyncProcedure(procedure);
2428 //                              dec();
2429
2430                         }
2431
2432                 }
2433
2434         }
2435
2436
2437         @Override
2438         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2439                         final AsyncMultiProcedure<T> procedure) {
2440
2441                 assert (request != null);
2442                 assert (procedure != null);
2443
2444                 ListenerBase listener = getListenerBase(procedure);
2445
2446                 if (parent != null || listener != null) {
2447
2448 //                      Object syncParent = request;
2449
2450 //                      final ReadGraphImpl newGraph = newSync();
2451
2452                         processor.query(this, request, parent, procedure, listener);
2453
2454 //                      newGraph.waitAsync(syncParent);
2455
2456                 } else {
2457
2458 //                      Object syncParent = request;
2459
2460 //                      final ReadGraphImpl newGraph = newSync();
2461
2462                         try {
2463
2464                                 request.perform(this, new AsyncMultiProcedure<T>() {
2465
2466                                         @Override
2467                                         public void execute(AsyncReadGraph graph, T result) {
2468                                                 procedure.execute(graph, result);
2469                                         }
2470
2471                                         @Override
2472                                         public void finished(AsyncReadGraph graph) {
2473                                                 procedure.finished(graph);
2474                                         }
2475
2476                                         @Override
2477                                         public void exception(AsyncReadGraph graph, Throwable t) {
2478                                                 procedure.exception(graph, t);
2479                                         }
2480
2481                                         @Override
2482                                         public String toString() {
2483                                                 return "syncRequest(AsyncMultiRead) -> " + procedure;
2484                                         }
2485
2486                                 });
2487
2488                         } catch (Throwable t) {
2489
2490                         }
2491
2492                 }
2493
2494                 // TODO!!
2495                 return null;
2496
2497         }
2498
2499         @Override
2500         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2501                         final SyncMultiProcedure<T> procedure) {
2502                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2503         }
2504
2505         @Override
2506         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2507                         final MultiProcedure<T> procedure) {
2508                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2509         }
2510
2511         @Override
2512         public <T> T syncRequest(final ExternalRead<T> request)
2513                         throws DatabaseException {
2514
2515                 assert (request != null);
2516
2517                 return syncRequest(request, new Procedure<T>() {
2518
2519                         @Override
2520                         public void execute(T t) {
2521                         }
2522
2523                         @Override
2524                         public void exception(Throwable t) {
2525                         }
2526
2527                         @Override
2528                         public String toString() {
2529                                 return "syncRequest(AsyncRead) -> " + request;
2530                         }
2531
2532                 });
2533
2534         }
2535
2536         @Override
2537         public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2538                 return syncRequest(request, (Procedure<T>) procedure);
2539         }
2540
2541         @Override
2542         final public <T> T syncRequest(final ExternalRead<T> request,
2543                         final Procedure<T> procedure) throws DatabaseException {
2544
2545                 assert (request != null);
2546
2547                 ListenerBase listener = getListenerBase(procedure);
2548
2549                 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2550                 final DataContainer<T> result = new DataContainer<T>();
2551
2552                 if (parent != null || listener != null) {
2553
2554 //                      final ReadGraphImpl newGraph = newSync();
2555
2556                         processor.query(this, request, parent, new Procedure<T>() {
2557
2558                                 @Override
2559                                 public void exception(Throwable throwable) {
2560                                         exception.set(throwable);
2561                                         procedure.exception(throwable);
2562                                 }
2563
2564                                 @Override
2565                                 public void execute(T t) {
2566                                         result.set(t);
2567                                         procedure.execute(t);
2568                                 }
2569
2570                         }, listener);
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                                 processor.queryRead(this, request, parent, procedure,
5410                                                 listener);
5411                         } catch (Throwable e) {
5412                                 // This throwable has already been transferred to procedure at this point - do nothing about it
5413                                 //Logger.defaultLogError("Internal error ", e);
5414                         }
5415
5416                 } else {
5417
5418 //                      final ReadGraphImpl newGraph = newSync();
5419
5420                         try {
5421
5422                                 T result = request.perform(this);
5423
5424                                 try {
5425                                         procedure.execute(this, result);
5426                                 } catch (Throwable t) {
5427                                         Logger.defaultLogError(t);
5428                                 }
5429
5430                         } catch (Throwable t) {
5431
5432                                 try {
5433                                         procedure.exception(this, t);
5434                                 } catch (Throwable t2) {
5435                                         Logger.defaultLogError(t2);
5436                                 }
5437
5438                         } finally {
5439
5440                         }
5441
5442                 }
5443
5444         }
5445
5446     public static ReadGraphImpl createAsync(QueryProcessor support) {
5447         return new ReadGraphImpl(null, support);
5448     }
5449
5450     public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5451         return new ReadGraphImpl(entry, support);
5452     }
5453
5454         @Override
5455         public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5456                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5457         }
5458
5459         @Override
5460         public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5461                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5462         }
5463
5464         @Override
5465         final public <T> void asyncRequest(final AsyncRead<T> request) {
5466
5467                 assert (request != null);
5468
5469                 asyncRequest(request, new AsyncProcedure<T>() {
5470
5471                         @Override
5472                         public void execute(AsyncReadGraph graph, T result) {
5473                         }
5474
5475                         @Override
5476                         public void exception(AsyncReadGraph graph, Throwable t) {
5477                         Logger.defaultLogError(t);
5478                         }
5479
5480                         @Override
5481                         public String toString() {
5482                                 return "asyncRequest(AsyncRead) -> " + request;
5483                         }
5484
5485                 });
5486
5487         }
5488
5489         @Override
5490         public <T> void asyncRequest(AsyncRead<T> request,
5491                         AsyncListener<T> procedure) {
5492                 asyncRequest(request, (AsyncProcedure<T>) procedure);
5493         }
5494
5495         @Override
5496         final public <T> void asyncRequest(AsyncRead<T> request,
5497                         final SyncListener<T> procedure) {
5498                 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5499         }
5500
5501         @Override
5502         final public <T> void asyncRequest(AsyncRead<T> request,
5503                         final Listener<T> procedure) {
5504                 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5505         }
5506
5507         @Override
5508         final public <T> void asyncRequest(final AsyncRead<T> request,
5509                         final AsyncProcedure<T> procedure) {
5510
5511                 assert (request != null);
5512                 assert (procedure != null);
5513
5514                 final ListenerBase listener = getListenerBase(procedure);
5515
5516                 if (parent != null || listener != null) {
5517
5518                         processor.query(this, request, parent, procedure, listener);
5519
5520                 } else {
5521
5522                         try {
5523
5524                                 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
5525
5526                         } catch (Throwable t) {
5527
5528                                 if (t instanceof DatabaseException)
5529                                         procedure.exception(this, t);
5530                                 else
5531                                         procedure
5532                                                         .exception(
5533                                                                         this,
5534                                                                         new DatabaseException(
5535                                                                                         "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5536                                                                                         t));
5537
5538                         }
5539
5540                 }
5541
5542         }
5543
5544         @Override
5545         public <T> void asyncRequest(AsyncRead<T> request,
5546                         SyncProcedure<T> procedure) {
5547                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5548         }
5549
5550         @Override
5551         final public <T> void asyncRequest(final AsyncRead<T> request,
5552                         final Procedure<T> procedure) {
5553                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5554         }
5555
5556         @Override
5557         public <T> void asyncRequest(final MultiRead<T> request) {
5558
5559                 assert (request != null);
5560
5561                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5562                         @Override
5563                         public void exception(AsyncReadGraph graph, Throwable t) {
5564                         Logger.defaultLogError(t);
5565                         }
5566
5567                         @Override
5568                         public String toString() {
5569                                 return "asyncRequest(MultiRead) -> " + request;
5570                         }
5571                 });
5572
5573         }
5574
5575         @Override
5576         public <T> void asyncRequest(MultiRead<T> request,
5577                         AsyncMultiListener<T> procedure) {
5578                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5579         }
5580
5581         @Override
5582         public <T> void asyncRequest(MultiRead<T> request,
5583                         SyncMultiListener<T> procedure) {
5584                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5585         }
5586
5587         @Override
5588         public <T> void asyncRequest(MultiRead<T> request,
5589                         MultiListener<T> procedure) {
5590                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5591         }
5592
5593         @Override
5594         public <T> void asyncRequest(final MultiRead<T> request,
5595                         final AsyncMultiProcedure<T> procedure) {
5596
5597                 assert (request != null);
5598                 assert (procedure != null);
5599
5600                 final ListenerBase listener = getListenerBase(procedure);
5601
5602                 if (parent != null || listener != null) {
5603
5604 //                  final ReadGraphImpl newGraph = newSync();
5605                     processor.query(this, request, parent, procedure,listener);
5606
5607                 } else {
5608
5609 //                  final ReadGraphImpl newGraph = newSync();
5610
5611                     try {
5612
5613                         request.perform(this, procedure);
5614
5615                     } catch (Throwable t) {
5616
5617                         procedure.exception(this, t);
5618
5619                     }
5620
5621                 }
5622
5623         }
5624
5625         @Override
5626         public <T> void asyncRequest(MultiRead<T> request,
5627                         SyncMultiProcedure<T> procedure) {
5628                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5629         }
5630
5631         @Override
5632         public <T> void asyncRequest(MultiRead<T> request,
5633                         MultiProcedure<T> procedure) {
5634                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5635         }
5636
5637         @Override
5638         final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5639
5640                 assert (request != null);
5641
5642                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5643                         @Override
5644                         public void exception(AsyncReadGraph graph, Throwable t) {
5645                         Logger.defaultLogError(t);
5646                         }
5647
5648                         @Override
5649                         public String toString() {
5650                                 return "asyncRequest(AsyncMultiRead) -> " + request;
5651                         }
5652                 });
5653
5654         }
5655
5656         @Override
5657         public <T> void asyncRequest(AsyncMultiRead<T> request,
5658                         AsyncMultiListener<T> procedure) {
5659                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5660         }
5661
5662         @Override
5663         public <T> void asyncRequest(AsyncMultiRead<T> request,
5664                         SyncMultiListener<T> procedure) {
5665                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5666         }
5667
5668         @Override
5669         public <T> void asyncRequest(AsyncMultiRead<T> request,
5670                         MultiListener<T> procedure) {
5671                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5672         }
5673
5674         @Override
5675         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5676                         final AsyncMultiProcedure<T> procedure) {
5677
5678                 assert (request != null);
5679                 assert (procedure != null);
5680
5681                 ListenerBase listener = getListenerBase(procedure);
5682
5683                 if (parent != null || listener != null) {
5684
5685                         processor.query(this, request, parent, procedure, listener);
5686
5687                 } else {
5688
5689                         try {
5690
5691                                 request.perform(this, new AsyncMultiProcedure<T>() {
5692
5693                                         @Override
5694                                         public void execute(AsyncReadGraph graph, T result) {
5695                                                 procedure.execute(graph, result);
5696                                         }
5697
5698                                         @Override
5699                                         public void finished(AsyncReadGraph graph) {
5700                                                 procedure.finished(graph);
5701                                         }
5702
5703                                         @Override
5704                                         public void exception(AsyncReadGraph graph, Throwable t) {
5705                                                 procedure.exception(graph, t);
5706                                         }
5707
5708                                         @Override
5709                                         public String toString() {
5710                                                 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5711                                         }
5712
5713                                 });
5714
5715                         } catch (Throwable t) {
5716
5717                                 procedure.exception(this, new DatabaseException(t));
5718
5719                         }
5720                 }
5721
5722         }
5723
5724         @Override
5725         public <T> void asyncRequest(AsyncMultiRead<T> request,
5726                         SyncMultiProcedure<T> procedure) {
5727                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5728         }
5729
5730         @Override
5731         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5732                         final MultiProcedure<T> procedure) {
5733                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5734         }
5735
5736         @Override
5737         final public <T> void asyncRequest(final ExternalRead<T> request) {
5738
5739                 assert (request != null);
5740
5741                 asyncRequest(request, new Procedure<T>() {
5742
5743                         @Override
5744                         public void execute(T result) {
5745                         }
5746
5747                         @Override
5748                         public void exception(Throwable t) {
5749                         Logger.defaultLogError(t);
5750                         }
5751
5752                         @Override
5753                         public String toString() {
5754                                 return "asyncRequest(PrimitiveRead) -> " + request;
5755                         }
5756
5757                 });
5758
5759         }
5760
5761         @Override
5762         public <T> void asyncRequest(ExternalRead<T> request,
5763                         final Listener<T> procedure) {
5764                 asyncRequest(request, (Procedure<T>) procedure);
5765         }
5766
5767         @Override
5768         final public <T> void asyncRequest(final ExternalRead<T> request,
5769                         final Procedure<T> procedure) {
5770
5771                 assert (request != null);
5772                 assert (procedure != null);
5773
5774                 ListenerBase listener = getListenerBase(procedure);
5775
5776                 if (parent != null || listener != null) {
5777
5778                         processor.query(this, request, parent, procedure, listener);
5779
5780                 } else {
5781
5782                         try {
5783
5784                                 request.register(this, new Listener<T>() {
5785
5786                                         @Override
5787                                         public void execute(T result) {
5788                                                 procedure.execute(result);
5789                                         }
5790
5791                                         @Override
5792                                         public void exception(Throwable t) {
5793                                                 procedure.exception(t);
5794                                         }
5795
5796                                         @Override
5797                                         public String toString() {
5798                                                 return "asyncRequest(PrimitiveRead) -> " + request;
5799                                         }
5800
5801                                         @Override
5802                                         public boolean isDisposed() {
5803                                                 return true;
5804                                         }
5805
5806                                 });
5807
5808                         } catch (Throwable t) {
5809
5810                                 if (t instanceof DatabaseException)
5811                                         procedure.exception(t);
5812                                 else
5813                                         procedure
5814                                                         .exception(new DatabaseException(
5815                                                                         "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5816                                                                         t));
5817
5818                         }
5819
5820                 }
5821
5822         }
5823
5824         @Override
5825         public void asyncRequest(final Write request) {
5826
5827                 assert (request != null);
5828
5829                 getSession().asyncRequest(request);
5830
5831 //              processor.asyncWrite(request);
5832
5833         }
5834
5835         @Override
5836         public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5837                 throw new Error("Not implemented.");
5838         }
5839
5840         @Override
5841         public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5842
5843                 assert (request != null);
5844
5845                 getSession().asyncRequest(request, callback);
5846
5847         }
5848
5849         @Override
5850         public void asyncRequest(final DelayedWrite request) {
5851
5852                 assert (request != null);
5853
5854                 getSession().asyncRequest(request);
5855
5856         }
5857
5858         @Override
5859         public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5860                 throw new Error("Not implemented.");
5861         }
5862
5863         @Override
5864         public void asyncRequest(DelayedWrite r,
5865                         Consumer<DatabaseException> callback) {
5866                 throw new Error("Not implemented.");
5867         }
5868
5869         @Override
5870         public void asyncRequest(final WriteOnly request) {
5871
5872                 assert (request != null);
5873
5874                 getSession().asyncRequest(request);
5875
5876         }
5877
5878         @Override
5879         public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5880                 throw new Error("Not implemented.");
5881         }
5882
5883         @Override
5884         public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5885                 throw new Error("Not implemented.");
5886         }
5887
5888         /*
5889          * Implementation of the interface ServiceLocator
5890          */
5891
5892         @Override
5893         public <T> T getService(Class<T> api) {
5894             if(WriteSupport.class == api) {
5895                 if(this instanceof WriteGraphImpl) {
5896                     WriteGraphImpl impl = (WriteGraphImpl)this;
5897                     return (T)impl.writeSupport;
5898                 }
5899             }
5900                 return getSession().getService(api);
5901         }
5902
5903         @Override
5904         public <T> T peekService(Class<T> api) {
5905                 return getSession().peekService(api);
5906         }
5907
5908         @Override
5909         public boolean hasService(Class<?> api) {
5910                 return getSession().hasService(api);
5911         }
5912
5913         @Override
5914         public <T> void registerService(Class<T> api, T service) {
5915                 getSession().registerService(api, service);
5916         }
5917
5918         @Override
5919         public boolean isImmutable(Resource resource) throws DatabaseException {
5920                 ResourceImpl impl = (ResourceImpl)resource;
5921                 return processor.isImmutable(impl.id);
5922         }
5923
5924         /*
5925          * Internal routines
5926          */
5927
5928         protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
5929
5930         /*
5931          * callerThread is the currently running thread state.syncThread is blocking for
5932          * this execution state.syncParent is the blocking request
5933          */
5934
5935         final private boolean isExternal(int thread) {
5936                 return thread == Integer.MIN_VALUE;
5937         }
5938
5939 //      final private boolean isSync(int thread) {
5940 //              return thread < -1 && thread > Integer.MIN_VALUE;
5941 //      }
5942
5943         ReadGraphImpl(ReadGraphImpl graph) {
5944                 this(graph.parent, graph.processor);
5945         }
5946
5947         ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
5948 //              this.state = new ReadGraphState(barrier, support);
5949                 this.parent = parent;
5950                 this.processor = support;
5951         }
5952
5953         ReadGraphImpl(final QueryProcessor support) {
5954
5955 //              this.state = state;
5956                 this.processor = support;
5957                 this.parent = null;
5958
5959         }
5960
5961 //      public static ReadGraphImpl createSync(int syncThread, Object syncParent,
5962 //                      ReadGraphSupportImpl support) {
5963 //              return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
5964 //                              support, new AsyncBarrierImpl(null));
5965 //      }
5966
5967         public static ReadGraphImpl create(QueryProcessor support) {
5968                 return new ReadGraphImpl(support);
5969         }
5970
5971 //      public ReadGraphImpl newAsync() {
5972 //              return this;
5973 ////            if(!state.synchronizedExecution) {
5974 ////                    return this;
5975 ////            } else {
5976 ////                    return new ReadGraphImpl(false, parent, state.support, state.barrier);
5977 ////            }
5978 //      }
5979
5980 //      public ReadGraphImpl newSync() {
5981 //              return new ReadGraphImpl(parent, processor);
5982 //      }
5983
5984         public ReadGraphImpl newSync(CacheEntry parentEntry) {
5985                 return new ReadGraphImpl(parentEntry, processor);
5986         }
5987
5988         public ReadGraphImpl newRestart(ReadGraphImpl impl) {
5989
5990                 WriteGraphImpl write = processor.getSession().getService(
5991                                 WriteGraphImpl.class);
5992
5993 //              if (write.callerThread != impl.callerThread)
5994 //                      return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
5995                 return write;
5996
5997         }
5998
5999 //      public ReadGraphImpl newSync(Object parentRequest) {
6000 //              return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6001 //      }
6002
6003 //      public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
6004 //              assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
6005 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6006 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6007 //      }
6008 //
6009 //      public ReadGraphImpl newSyncAsync(Object parentRequest) {
6010 ////            assert (callerThread < 0);
6011 //              return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6012 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6013 //      }
6014 //
6015 //      public ReadGraphImpl newSyncAsync(final int callerThread,
6016 //                      Object parentRequest) {
6017 ////            assert (callerThread < 0);
6018 //              // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6019 //              // && callerThread != Integer.MIN_VALUE) );
6020 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6021 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6022 //      }
6023
6024         public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6025                 return new ReadGraphImpl(parent, processor);
6026         }
6027
6028         public ReadGraphImpl withParent(CacheEntry parent) {
6029                 if(parent == this.parent) return this;
6030                 else return new ReadGraphImpl(parent, processor);
6031         }
6032
6033         final private ListenerBase getListenerBase(final Object procedure) {
6034                 if (procedure instanceof ListenerBase)
6035                         return (ListenerBase) procedure;
6036                 else
6037                         return null;
6038         }
6039
6040         public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6041
6042                 assert(procedure.done());
6043
6044 //              while (!procedure.done()) {
6045 //
6046 //                      boolean executed = processor.resumeTasks(callerThread, null, null);
6047 //                      if (!executed) {
6048 //                              try {
6049 //                                      Thread.sleep(1);
6050 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6051 //                              } catch (InterruptedException e) {
6052 //                                      e.printStackTrace();
6053 //                              }
6054 //                      }
6055 //
6056 //              }
6057
6058         }
6059
6060         public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6061
6062                 assert(procedure.done());
6063
6064 //              while (!procedure.done()) {
6065 //
6066 //                      boolean executed = processor.processor.resume(this);
6067 //                      if (!executed) {
6068 //                              try {
6069 //                                      Thread.sleep(1);
6070 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6071 //                              } catch (InterruptedException e) {
6072 //                                      e.printStackTrace();
6073 //                              }
6074 //                      }
6075 //
6076 //              }
6077
6078         }
6079
6080 //      public void waitAsync(Object request) {
6081 //              try {
6082 //                      state.barrier.waitBarrier(request, this);
6083 //              } catch (Throwable t) {
6084 //                      t.printStackTrace();
6085 //                      processor.scanPending();
6086 //                      processor.querySupport.checkTasks();
6087 //                      throw new RuntimeDatabaseException(t);
6088 //              }
6089 //      }
6090
6091 //      public void restart() {
6092 //              state.barrier.restart();
6093 //      }
6094
6095         public boolean resumeTasks() {
6096                 return processor.resumeTasks(this);
6097         }
6098
6099         Class<?> singleClass(Set<Resource> types) {
6100                 Class<?> result = null;
6101                 for (Resource type : types) {
6102                         Class<?> clazz = processor.getBuiltinValue(type);
6103                         if (clazz != null) {
6104                                 if (result != null)
6105                                         return null;
6106                                 else
6107                                         result = clazz;
6108                         }
6109                 }
6110                 return result;
6111         }
6112
6113         private String debugString(Resource r) {
6114                 String name = null;
6115                 try {
6116                         name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6117                 } catch (ManyObjectsForFunctionalRelationException e) {
6118                 Logger.defaultLogError(e);
6119                 } catch (ServiceException e) {
6120                 Logger.defaultLogError(e);
6121                 }
6122                 return "[" + name + " - " + r + "]";
6123         }
6124
6125         @Override
6126         public String toString() {
6127                 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6128         }
6129
6130         @Override
6131         final public int thread() {
6132                 return 0;
6133         }
6134
6135     static class MultiTripleIntProcedure implements TripleIntProcedure {
6136
6137         final private AsyncMultiProcedure<Statement> procedure;
6138         final private ReadGraphImpl impl;
6139         final private QuerySupport support;
6140
6141         public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6142                 this.procedure = procedure;
6143                 this.impl = impl;
6144                 this.support = support;
6145         }
6146
6147         @Override
6148         public void execute(ReadGraphImpl graph, int s, int p, int o) {
6149                 try {
6150                         procedure.execute(graph, support.getStatement(s, p, o));
6151                 } catch (Throwable t2) {
6152                         Logger.defaultLogError(t2);
6153                 }
6154         }
6155
6156         @Override
6157         public void finished(ReadGraphImpl graph) {
6158                 try {
6159                         procedure.finished(graph);
6160 //                      impl.state.barrier.dec("ReadGraphSupportImpl.516");
6161                 } catch (Throwable t2) {
6162                         Logger.defaultLogError(t2);
6163                 }
6164         }
6165
6166         @Override
6167         public void exception(ReadGraphImpl graph, Throwable t) {
6168                 try {
6169                         procedure.exception(graph, t);
6170                 } catch (Throwable t2) {
6171                         Logger.defaultLogError(t2);
6172                 }
6173 //              impl.state.barrier.dec("ReadGraphSupportImpl.516");
6174         }
6175
6176         @Override
6177         public String toString() {
6178                 return "forEachObject with " + procedure;
6179         }
6180
6181     }
6182
6183 //    private AsyncMultiProcedure<Resource> cacheKey = null;
6184 //    private MultiIntProcedure cacheResult = null;
6185 //
6186 //    final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6187 //
6188 //      if(procedure == cacheKey) return cacheResult;
6189 //
6190 //      cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6191 //      cacheKey = procedure;
6192 //
6193 //      return cacheResult;
6194 //
6195 //    }
6196 //
6197 //    private AsyncMultiProcedure<Statement> cacheKey2 = null;
6198 //    private MultiTripleIntProcedure cacheResult2 = null;
6199 //
6200 //    final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6201 //
6202 //      if(procedure == cacheKey2) return cacheResult2;
6203 //
6204 //      cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6205 //      cacheKey2 = procedure;
6206 //
6207 //      return cacheResult2;
6208 //
6209 //    }
6210
6211     @Override
6212     public Datatype getDataType(Resource subject) throws DatabaseException {
6213         for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6214                 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6215         throw new DoesNotContainValueException("The literal has no data type.");
6216     }
6217
6218     protected <T extends Accessor> T getAccessor4File(Resource subject)
6219     throws DatabaseException {
6220         return null;
6221         /*
6222         byte[]  bytes = processor.support.getValue(g, subject);
6223         if (null == bytes)
6224             return null;
6225         try {
6226             BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6227             Accessor ca = va.getContentAccessor();
6228             return (T)ca;
6229         } catch (AccessorConstructionException e) {
6230             throw new DatabaseException(e);
6231         }
6232         */
6233         /*
6234         if (null == bytes)
6235             return null;
6236         Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6237         Serializer datatype_serializer = datatype_binding.serializer();
6238         DataType datatype;
6239         try {
6240             BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6241             datatype = (DataType)datatype_serializer.deserialize(in);
6242             Binding data_binding = Bindings.getBinding(datatype);
6243             Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6244             Object o = data_serializer.deserialize(in);
6245             try {
6246                 return (T)Accessors.getAccessor(data_binding, o);
6247             } catch(AccessorConstructionException e) {
6248                 return null;
6249             }
6250         } catch (Exception e) {
6251             throw new DatabaseException(e);
6252         }*/
6253     }
6254     @SuppressWarnings("unchecked")
6255     @Override
6256     public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6257         RandomAccessBinary rab = getRandomAccessBinary(subject);
6258         try {
6259             return (T)Accessors.getAccessor(rab, getDataType(subject));
6260         } catch(AccessorConstructionException e) {
6261             throw new DatabaseException(e);
6262         }
6263     }
6264     @SuppressWarnings("unchecked")
6265     protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6266     throws DatabaseException {
6267         RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6268         try {
6269             return (T)Accessors.getAccessor(rab, datatype);
6270         } catch(AccessorConstructionException e) {
6271             throw new DatabaseException(e);
6272         }
6273     }
6274     @Override
6275     public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6276         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6277         ResourceData rd = ravs.get(subject);
6278         if (null != rd)
6279             return rd;
6280         try {
6281             ExternalValueSupport evs = getService(ExternalValueSupport.class);
6282             long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6283             try {
6284                 File platform = Platform.getLocation().toFile();
6285                 File tempFiles = new File(platform, "tempFiles");
6286                 File dbDir = new File(tempFiles, "db");
6287                 dbDir.mkdirs();
6288                 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6289                 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6290                 final int N = 1<<20;
6291                 long left = size;
6292                 long offset = 0;
6293                 while (left > 0) {
6294                     int length = N < left ? N : (int)left;
6295                     byte[] bytes = evs.readValue(this, subject, offset, length);
6296                     offset += bytes.length;
6297                     left -= bytes.length;
6298                     rd.binaryFile.write(bytes);
6299                 }
6300                 ravs.put(subject, rd);
6301                 return rd;
6302             } catch (Exception e) {
6303                 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6304             }
6305         } catch (Exception e) {
6306             if(Development.DEVELOPMENT) {
6307                 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6308                     e.printStackTrace();
6309                 }
6310             }
6311         }
6312         Datatype datatype = getDataType(subject);
6313         Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6314         return createRandomAccessBinary(subject, datatype, value);
6315     }
6316     public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6317     throws DatabaseException {
6318         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6319         try {
6320             File platform = Platform.getLocation().toFile();
6321             File tempFiles = new File(platform, "tempFiles");
6322             File dbDir = new File(tempFiles, "db");
6323             dbDir.mkdirs();
6324             File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6325             ResourceData rd = new ResourceData(new BinaryFile(file), false);
6326             Binding binding = Bindings.getBinding(datatype);
6327             if (null == initialValue) {
6328                 initialValue = binding.createDefault();
6329             }
6330             Serializer serializer = binding.serializer();
6331             byte[] bytes = serializer.serialize(initialValue);
6332             rd.binaryFile.write(bytes);
6333             ravs.put(resource, rd);
6334             return rd;
6335         } catch (Exception e) {
6336             if (e instanceof DatabaseException)
6337                 throw (DatabaseException)e;
6338             else
6339                 throw new DatabaseException(e);
6340         }
6341     }
6342
6343 //    static class ExternalValueRequest<T> extends ResourceRead<T> {
6344 //
6345 //              public ExternalValueRequest(Resource resource) {
6346 //                      super(resource);
6347 //              }
6348 //
6349 //              @SuppressWarnings("unchecked")
6350 //              @Override
6351 //              public T perform(ReadGraph graph) throws DatabaseException {
6352 //              try {
6353 //
6354 //                      String uri = graph.getURI(resource);
6355 //                      if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6356 //
6357 //                      return (T)ReflectionUtils.getValue(uri).getValue();
6358 //
6359 //              } catch(ValueNotFoundException e) {
6360 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6361 //              } catch(ClassCastException e) {
6362 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6363 //              }
6364 //              }
6365 //
6366 //    }
6367
6368     @SuppressWarnings("unchecked")
6369     @Override
6370     public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6371         Layer0 L0 = processor.getL0(this);
6372         Set<Resource> types = getTypes(r);
6373
6374         if(types.contains(L0.Literal)) {
6375                 if(isImmutable(r)) {
6376                         return syncRequest(new ValueImplied<T>(r));
6377                 } else {
6378                         return getValue(r);
6379                 }
6380         }
6381         else if(types.contains(L0.ExternalValue)) {
6382                 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6383         }
6384         else {
6385
6386             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6387             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6388             try {
6389                 return function.apply(this, r, context);
6390             } catch(RuntimeException e) {
6391                 DatabaseException dte = findPossibleRootException(e);
6392                 if(dte != null) throw dte;
6393                 else throw new DatabaseException(e);
6394             }
6395
6396         }
6397     }
6398
6399     @Override
6400     public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6401         Layer0 L0 = processor.getL0(this);
6402         Set<Resource> types = getTypes(r);
6403
6404         if(types.contains(L0.Literal)) {
6405             if(isImmutable(r)) {
6406                 return syncRequest(new VariantValueImplied(r));
6407             } else {
6408                 return getVariantValue(r);
6409             }
6410         }
6411         else if(types.contains(L0.ExternalValue)) {
6412             Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6413             try {
6414                 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6415             } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6416                 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6417             }
6418         }
6419         else {
6420
6421             Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6422             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6423             try {
6424                 Object value = function.apply(this, r, context);
6425                 try {
6426                     return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6427                 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6428                     throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6429                 }
6430             } catch(RuntimeException e) {
6431                 DatabaseException dte = findPossibleRootException(e);
6432                 if(dte != null) throw dte;
6433                 else throw new DatabaseException(e);
6434             }
6435         }
6436     }
6437
6438     @Override
6439     public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6440         try {
6441                 return getValue2(subject, context);
6442         } catch (DatabaseException e) {
6443                 return null;
6444         }
6445     }
6446
6447     static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6448
6449         public PossibleConverterFunction(Resource resource) {
6450                         super(resource);
6451                 }
6452
6453         @Override
6454         public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6455                 return compute(graph, resource);
6456         }
6457
6458         @SuppressWarnings("unchecked")
6459                 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6460             Layer0 L0 = Layer0.getInstance(graph);
6461             for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6462                 try {
6463                         if(L0.Functions_functionApplication.equals(converter)) {
6464                                 return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6465                         } else {
6466                                 return graph.getValue2(converter, resource);
6467                         }
6468                 } catch(RuntimeException e) {
6469                     DatabaseException dte = findPossibleRootException(e);
6470                     if(dte != null) throw dte;
6471                     else throw new DatabaseException(e);
6472                 }
6473             }
6474             return null;
6475         }
6476
6477     }
6478
6479     <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6480         if(isImmutable(r))
6481                 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6482         else
6483                 return syncRequest(new PossibleConverterFunction<T>(r));
6484     }
6485
6486     /**
6487      * Get a value associated with a graph {@link Resource}, using a possible context object and
6488      * a desired value binding. The following methods are tried in order to retreive the value:
6489      * <ol>
6490      *   <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>
6491      *   <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6492      *       {@link ReflectionUtils#getValue(String)}.</li>
6493      *   <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6494      *       (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6495      *       and the context object.</li>
6496      * </ul>
6497      *
6498      * @param r  A graph resource with which the value is associated
6499      * @param context  A context object that is used for acquiring the value (only applied in case 3)
6500      * @param binding  A binding for the value type (only applied in case 1)
6501      * @return  The value of the graph node.
6502      * @throws DoesNotContainValueException  No value is associated with the graph node.
6503      * @throws DatabaseException  Other errors, such as an error in casting the value to the return type or
6504      *         a runtime error in the value function.
6505      */
6506     @SuppressWarnings("unchecked")
6507         @Override
6508     public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6509         if (binding instanceof ObjectVariantBinding)
6510                 return getValue2(r, context);
6511
6512         Layer0 L0 = processor.getL0(this);
6513         Set<Resource> types = getTypes(r);
6514         if(types.contains(L0.Literal)) {
6515                 if(isImmutable(r)) {
6516                         return syncRequest(new Value<T>(r, binding));
6517                 } else {
6518                         return getValue(r, binding);
6519                 }
6520         } else if(types.contains(L0.ExternalValue)) {
6521                 try {
6522                         return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6523                 } catch(ValueNotFoundException e) {
6524                         throw new DatabaseException(e);
6525                 } catch(ClassCastException e) {
6526                         throw new DatabaseException(e);
6527                 }
6528         }
6529         else {
6530             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6531             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6532             try {
6533                 Object value = function.apply(this, r, context);
6534                 if(binding.isInstance(value)) return (T)value;
6535                 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6536                 return (T)Bindings.adapt(value, srcBinding, binding);
6537             } catch(RuntimeException e) {
6538                 DatabaseException dte = findPossibleRootException(e);
6539                 if(dte != null) throw dte;
6540                 else throw new DatabaseException(e);
6541             } catch (AdaptException e) {
6542                 throw new DatabaseException(e);
6543                         } catch (org.simantics.databoard.binding.error.BindingException e) {
6544                 throw new DatabaseException(e);
6545                         }
6546         }
6547     }
6548
6549     @Override
6550     public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6551         try {
6552                 return getValue2(subject, context, binding);
6553         } catch (DatabaseException e) {
6554                 return null;
6555         }
6556     }
6557
6558         private static DatabaseException findPossibleRootException(Throwable t) {
6559                 if(t == null) return null;
6560                 if(t instanceof DatabaseException) return (DatabaseException)t;
6561                 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6562                         return findPossibleRootException(t.getCause());
6563                 }
6564                 return null;
6565         }
6566
6567     @Override
6568     public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6569         return getRelatedValue2(subject, relation, subject);
6570     }
6571
6572     @Override
6573     public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6574         return getRelatedVariantValue2(subject, relation, subject);
6575     }
6576
6577     @Override
6578     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6579         try {
6580                 Resource object = getPossibleObject(subject, relation);
6581                 if(object == null) return null;
6582                 else return getValue2(object, subject);
6583         } catch (DatabaseException e) {
6584                 return null;
6585         }
6586     }
6587
6588     @Override
6589     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6590                 if(Development.DEVELOPMENT) {
6591                         String error = L0Validations.checkValueType(this, subject, relation);
6592                         if(error != null) {
6593                                 Logger.defaultLogError(new ValidationException(error));
6594                                 //throw new ValidationException(error);
6595                                 new ValidationException(error).printStackTrace();
6596                         }
6597                 }
6598         return getValue2(getSingleObject(subject, relation), context);
6599     }
6600
6601     @Override
6602     public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6603         if(Development.DEVELOPMENT) {
6604             String error = L0Validations.checkValueType(this, subject, relation);
6605             if(error != null) {
6606                 Logger.defaultLogError(new ValidationException(error));
6607                 //throw new ValidationException(error);
6608                 new ValidationException(error).printStackTrace();
6609             }
6610         }
6611         return getVariantValue2(getSingleObject(subject, relation), context);
6612     }
6613
6614     @Override
6615     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6616         try {
6617                 Resource object = getPossibleObject(subject, relation);
6618                 if(object == null) return null;
6619                 else return getValue2(object, context);
6620         } catch (DatabaseException e) {
6621                 return null;
6622         }
6623     }
6624
6625     @Override
6626     public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6627         return getRelatedValue2(subject, relation, subject, binding);
6628     }
6629
6630     @Override
6631     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6632         try {
6633                 Resource object = getPossibleObject(subject, relation);
6634                 if(object == null) return null;
6635                 return getValue2(object, subject, binding);
6636         } catch (DatabaseException e) {
6637                 return null;
6638         }
6639     }
6640
6641     @Override
6642     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6643         return getValue2(getSingleObject(subject, relation), context, binding);
6644     }
6645
6646     @Override
6647     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6648         try {
6649                 Resource object = getPossibleObject(subject, relation);
6650                 if(object == null) return null;
6651                 else return getValue2(object, context, binding);
6652         } catch (DatabaseException e) {
6653                 return null;
6654         }
6655     }
6656
6657     @Override
6658     public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6659         Layer0 L0 = processor.getL0(this);
6660         Resource property = getSingleObject(subject, relation);
6661         String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6662         try {
6663             return org.simantics.scl.compiler.types.Types.parseType(typeText);
6664         } catch (SCLTypeParseException e) {
6665             throw new DatabaseException(e);
6666         }
6667     }
6668
6669     @Override
6670     public boolean setSynchronous(boolean value) {
6671         boolean old = processor.synch;
6672         processor.synch = value;
6673         return old;
6674     }
6675
6676     @Override
6677     public boolean getSynchronous() {
6678         return processor.synch;
6679     }
6680
6681     public void ensureLoaded(int resource) {
6682         processor.querySupport.ensureLoaded(this, resource);
6683     }
6684
6685     public void ensureLoaded(int resource, int predicate) {
6686         processor.querySupport.ensureLoaded(this, resource, predicate);
6687     }
6688
6689     public byte[] getValue(int resource) {
6690         return processor.querySupport.getValue(this, resource);
6691     }
6692
6693     public int thread(int resource) {
6694         return (resource >>> 16) & processor.THREAD_MASK;
6695     }
6696
6697     public int thread(Resource resource) {
6698         return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6699     }
6700
6701     public ResourceSupport getResourceSupport() {
6702         return processor.getResourceSupport();
6703     }
6704
6705     @Override
6706     public Object getModificationCounter() {
6707         return processor.getSession().getModificationCounter();
6708     }
6709
6710 }