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                 return processor.query(this, request, parent, null, null);
1900
1901 //              if (parent != null) {
1902 //
1903 //                      try {
1904 //                      } catch (Throwable e) {
1905 //                              if(e instanceof DatabaseException) throw (DatabaseException)e;
1906 //                              else throw new DatabaseException(e);
1907 //                      }
1908 //
1909 //              } else {
1910 //
1911 //                      try {
1912 //
1913 //                              return processor.tryQuery(this, request);
1914 //
1915 //                      } catch (Throwable throwable) {
1916 //
1917 //                              //Logger.defaultLogError("Internal read request failure", throwable);
1918 //
1919 //                              if (throwable instanceof DatabaseException)
1920 //                                      throw (DatabaseException) throwable;
1921 //                              else
1922 //                                      throw new DatabaseException(
1923 //                                                      "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1924 //                                                      throwable);
1925 //
1926 //                      }
1927 //
1928 //              }
1929
1930         }
1931
1932         @Override
1933         public <T> T syncRequest(Read<T> request, SyncListener<T> procedure)
1934                         throws DatabaseException {
1935                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
1936         }
1937
1938         @Override
1939         public <T> T syncRequest(Read<T> request, final Listener<T> procedure)
1940                         throws DatabaseException {
1941                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
1942         }
1943
1944         @Override
1945         public <T> T syncRequest(final Read<T> request, final AsyncProcedure<T> procedure) throws DatabaseException {
1946
1947                 assert (request != null);
1948
1949                 ListenerBase listener = procedure != null ? getListenerBase(procedure) : null;
1950
1951         return processor.query(this, request, parent, procedure, listener);
1952
1953
1954 //              if (parent != null || listener != null) {
1955 //
1956 //                      try {
1957 //            } catch (Throwable e) {
1958 //                if(e instanceof DatabaseException) throw (DatabaseException)e;
1959 //                else throw new DatabaseException(e);
1960 //            }
1961 //
1962 //              } else {
1963 //
1964 //                      try {
1965 //
1966 //                              T t = processor.tryQuery(this, request);
1967 //                              if(procedure != null)
1968 //                                      procedure.execute(this, t);
1969 //
1970 //                              return t;
1971 //
1972 //                      } catch (Throwable throwable) {
1973 //
1974 //                              Logger.defaultLogError("Internal read request failure", throwable);
1975 //
1976 //                              if(procedure != null)
1977 //                                      procedure.exception(this, throwable);
1978 //
1979 //                              if (throwable instanceof DatabaseException)
1980 //                                      throw (DatabaseException) throwable;
1981 //                              else
1982 //                                      throw new DatabaseException(
1983 //                                                      "Unexpected exception in ReadGraph.syncRequest(Read,Procedure)",
1984 //                                                      throwable);
1985 //
1986 //                      }
1987 //
1988 //              }
1989
1990         }
1991
1992         @Override
1993         public <T> T syncRequest(final Read<T> request,
1994                         final SyncProcedure<T> procedure) throws DatabaseException {
1995                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
1996         }
1997
1998         @Override
1999         public <T> T syncRequest(Read<T> request, Procedure<T> procedure)
2000                         throws DatabaseException {
2001                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2002         }
2003
2004         static class AsyncReadProcedure<T> implements AsyncProcedure<T> {
2005
2006                 private static Throwable DONE = new Throwable();
2007
2008                 T result = null;
2009                 Throwable exception = null;
2010
2011                 @Override
2012                 public void execute(AsyncReadGraph graph, T t) {
2013                         result = t;
2014                         exception = DONE;
2015                 }
2016
2017                 @Override
2018                 public void exception(AsyncReadGraph graph, Throwable t) {
2019                         exception = t;
2020                 }
2021
2022                 public void checkAndThrow() throws DatabaseException {
2023                         if(exception != DONE) {
2024                                 if (exception instanceof DatabaseException)
2025                                         throw (DatabaseException) exception;
2026                                 else
2027                                         throw new DatabaseException(
2028                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2029                                                         exception);
2030                         }
2031                 }
2032
2033                 public boolean done() {
2034                         return exception != null;
2035                 }
2036
2037         }
2038
2039         @Override
2040         public <T> T syncRequest(final AsyncRead<T> request)
2041                         throws DatabaseException {
2042
2043                 assert (request != null);
2044                 AsyncReadProcedure<T> procedure = new AsyncReadProcedure<T>();
2045                 syncRequest(request, procedure);
2046                 procedure.checkAndThrow();
2047                 return procedure.result;
2048
2049 //              return syncRequest(request, new AsyncProcedureAdapter<T>());
2050
2051         }
2052
2053         @Override
2054         public <T> T syncRequest(AsyncRead<T> request, AsyncListener<T> procedure)
2055                         throws DatabaseException {
2056                 return syncRequest(request, (AsyncProcedure<T>) procedure);
2057         }
2058
2059         @Override
2060         public <T> T syncRequest(AsyncRead<T> request, SyncListener<T> procedure)
2061                         throws DatabaseException {
2062                 return syncRequest(request, new SyncToAsyncListener<T>(procedure));
2063         }
2064
2065         @Override
2066         public <T> T syncRequest(AsyncRead<T> request, Listener<T> procedure)
2067                         throws DatabaseException {
2068                 return syncRequest(request, new NoneToAsyncListener<T>(procedure));
2069         }
2070
2071         @Override
2072         final public <T> T syncRequest(final AsyncRead<T> request,
2073                         final AsyncProcedure<T> procedure) throws DatabaseException {
2074
2075                 assert (request != null);
2076
2077                 ListenerBase listener = getListenerBase(procedure);
2078
2079                 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2080                                 procedure, request);
2081
2082                 processor.query(this, request, parent, wrapper, listener);
2083
2084                 return wrapper.getResult();
2085
2086 //              if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2087 //
2088 ////                    Object syncParent = request;
2089 //
2090 ////                    final ReadGraphImpl newGraph = newSync();
2091 //
2092 //
2093 ////                    newGraph.waitAsync(syncParent);
2094 //
2095 //                      Throwable e = wrapper.getException();
2096 //                      if (e != null) {
2097 //                              // The request was async - produce meaningful stack trace by
2098 //                              // wrapping
2099 //                              if (e instanceof DatabaseException)
2100 //                                      throw (DatabaseException) e;
2101 //                              else
2102 //                                      throw new DatabaseException(e);
2103 //                      }
2104 //
2105 //                      return wrapper.getResult();
2106 //
2107 //              } else {
2108 //
2109 //                      // System.out.println("direct call " + request );
2110 //
2111 //                      // Do not set the sync state.parent for external threads
2112 ////                    Object syncParent = request;
2113 //
2114 ////                    final ReadGraphImpl newGraph = newSync();
2115 //
2116 //                      final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2117 //                                      procedure, request);
2118 //
2119 //                      try {
2120 //
2121 //                              processor.tryQuery(this, request, wrapper);
2122 //
2123 //                      } catch (Throwable t) {
2124 //
2125 //                              wrapper.exception(this, t);
2126 //
2127 //                      }
2128 //
2129 //                      Throwable e = wrapper.getException();
2130 //                      if (e != null) {
2131 //                              // The request was async - produce meaningful stack trace by
2132 //                              // wrapping
2133 //                              if (e instanceof DatabaseException)
2134 //                                      throw (DatabaseException) e;
2135 //                              else
2136 //                                      throw new DatabaseException(e);
2137 //                      }
2138 //
2139 //                      return wrapper.getResult();
2140 //
2141 //              }
2142
2143         }
2144
2145         final private <T> void syncRequest(final AsyncRead<T> request, final AsyncReadProcedure<T> procedure) throws DatabaseException {
2146
2147                 assert (request != null);
2148
2149                 ListenerBase listener = getListenerBase(procedure);
2150
2151                 final ResultCallWrappedSingleQueryProcedure4<T> wrapper = new ResultCallWrappedSingleQueryProcedure4<T>(
2152                                 procedure, request);
2153
2154                 processor.query(this, request, parent, wrapper, listener);
2155
2156 //              if (parent != null || listener != null || ((request.getFlags() & RequestFlags.SCHEDULE) > 0)) {
2157 //
2158 //
2159 //              } else {
2160 //
2161 //                      try {
2162 //
2163 ////                            final ReadGraphImpl newGraph = newSync();
2164 //                              processor.tryQuery(this, request, procedure);
2165 ////                            newGraph.waitAsync(null);
2166 //                              waitAsyncProcedure(procedure);
2167 //
2168 //                      } catch (Throwable t) {
2169 //                              if(Development.DEVELOPMENT) {
2170 //                                      if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
2171 //                                      t.printStackTrace();
2172 //                                      }
2173 //                              }
2174 //                              procedure.exception(this, t);
2175 //                              waitAsyncProcedure(procedure);
2176 //                      }
2177 //
2178 //              }
2179
2180         }
2181
2182         @Override
2183         public <T> T syncRequest(AsyncRead<T> request,
2184                         final SyncProcedure<T> procedure) throws DatabaseException {
2185                 return syncRequest(request, new SyncToAsyncProcedure<T>(procedure));
2186         }
2187
2188         @Override
2189         final public <T> T syncRequest(final AsyncRead<T> request,
2190                         final Procedure<T> procedure) throws DatabaseException {
2191                 return syncRequest(request, new NoneToAsyncProcedure<T>(procedure));
2192         }
2193
2194         @Override
2195         public <T> Collection<T> syncRequest(final MultiRead<T> request)
2196                         throws DatabaseException {
2197
2198                 assert (request != null);
2199
2200                 final ArrayList<T> result = new ArrayList<T>();
2201                 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2202
2203                 syncRequest(request, new AsyncMultiProcedure<T>() {
2204
2205                         @Override
2206                         public void execute(AsyncReadGraph graph, T t) {
2207                                 synchronized (result) {
2208                                         result.add(t);
2209                                 }
2210                         }
2211
2212                         @Override
2213                         public void finished(AsyncReadGraph graph) {
2214                         }
2215
2216                         @Override
2217                         public void exception(AsyncReadGraph graph, Throwable t) {
2218                                 exception.set(t);
2219                         }
2220
2221                         @Override
2222                         public String toString() {
2223                                 return "syncRequest(MultiRead) -> " + request;
2224                         }
2225
2226                 });
2227
2228                 Throwable t = exception.get();
2229                 if (t != null) {
2230                         if (t instanceof DatabaseException)
2231                                 throw (DatabaseException) t;
2232                         else
2233                                 throw new DatabaseException(
2234                                                 "Unexpected exception in ReadGraph.syncRequest(Read)",
2235                                                 t);
2236                 }
2237
2238                 return result;
2239
2240         }
2241
2242         @Override
2243         public <T> Collection<T> syncRequest(MultiRead<T> request,
2244                         AsyncMultiListener<T> procedure) {
2245                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2246         }
2247
2248         @Override
2249         public <T> Collection<T> syncRequest(MultiRead<T> request,
2250                         SyncMultiListener<T> procedure) {
2251                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2252         }
2253
2254         @Override
2255         public <T> Collection<T> syncRequest(MultiRead<T> request,
2256                         MultiListener<T> procedure) {
2257                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2258         }
2259
2260         @Override
2261         public <T> Collection<T> syncRequest(MultiRead<T> request,
2262                         AsyncMultiProcedure<T> procedure) {
2263
2264                 assert (request != null);
2265
2266                 ListenerBase listener = getListenerBase(procedure);
2267
2268                 if (parent != null || listener != null) {
2269
2270 //                      Object syncParent = request;
2271
2272 //                      final ReadGraphImpl newGraph = newSync();
2273
2274                         processor.query(this, request, parent, procedure, listener);
2275
2276 //                      newGraph.waitAsync(syncParent);
2277
2278                 } else {
2279
2280 //                      Object syncParent = request;
2281
2282 //                      final ReadGraphImpl newGraph = newSync();
2283
2284                         final ResultCallWrappedQueryProcedure4<T> wrapper = new ResultCallWrappedQueryProcedure4<T>(procedure);
2285
2286                         try {
2287
2288                                 request.perform(this, wrapper);
2289
2290                         } catch (Throwable t) {
2291
2292                                 wrapper.exception(this, t);
2293 //                              newGraph.waitAsync(syncParent);
2294
2295                         }
2296
2297                 }
2298
2299                 // TODO
2300                 return null;
2301
2302         }
2303
2304         @Override
2305         public <T> Collection<T> syncRequest(MultiRead<T> request,
2306                         SyncMultiProcedure<T> procedure) {
2307                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2308         }
2309
2310         @Override
2311         public <T> Collection<T> syncRequest(MultiRead<T> request,
2312                         MultiProcedure<T> procedure) {
2313                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2314         }
2315
2316         static class AsyncMultiReadProcedure<T> extends ArrayList<T> implements AsyncMultiProcedure<T> {
2317
2318                 private static Throwable DONE = new Throwable();
2319
2320                 private static final long serialVersionUID = -6494230465108115812L;
2321
2322                 Throwable exception = null;
2323
2324                 @Override
2325                 public synchronized void execute(AsyncReadGraph graph, T t) {
2326                         add(t);
2327                 }
2328
2329                 @Override
2330                 public void finished(AsyncReadGraph graph) {
2331                         exception = DONE;
2332                 }
2333
2334                 @Override
2335                 public void exception(AsyncReadGraph graph, Throwable t) {
2336                         exception = t;
2337                 }
2338
2339                 public void checkAndThrow() throws DatabaseException {
2340                         if(exception != DONE) {
2341                                 if (exception instanceof DatabaseException)
2342                                         throw (DatabaseException) exception;
2343                                 else
2344                                         throw new DatabaseException(
2345                                                         "Unexpected exception in ReadGraph.syncRequest(AsyncMultiRead)",
2346                                                         exception);
2347                         }
2348                 }
2349
2350                 public boolean done() {
2351                         return exception != null;
2352                 }
2353
2354         }
2355
2356         @Override
2357         final public <T> Collection<T> syncRequest(AsyncMultiRead<T> request)
2358                         throws DatabaseException {
2359
2360                 assert (request != null);
2361
2362                 final AsyncMultiReadProcedure<T> procedure = new AsyncMultiReadProcedure<T>();
2363
2364                 syncRequest(request, procedure);
2365
2366                 procedure.checkAndThrow();
2367                 return procedure;
2368
2369         }
2370
2371         @Override
2372         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2373                         AsyncMultiListener<T> procedure) {
2374                 return syncRequest(request, (AsyncMultiProcedure<T>) procedure);
2375         }
2376
2377         @Override
2378         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2379                         SyncMultiListener<T> procedure) {
2380                 return syncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
2381         }
2382
2383         @Override
2384         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2385                         MultiListener<T> procedure) {
2386                 return syncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
2387         }
2388
2389         final private <T> void syncRequest(final AsyncMultiRead<T> request,
2390                         final AsyncMultiReadProcedure<T> procedure) {
2391
2392                 assert (request != null);
2393                 assert (procedure != null);
2394
2395                 ListenerBase listener = getListenerBase(procedure);
2396
2397                 if (parent != null || listener != null) {
2398
2399 //                      Object syncParent = request;
2400
2401 //                      final ReadGraphImpl newGraph = newSync();
2402
2403                         processor.query(this, request, parent, procedure, listener);
2404
2405 //                      newGraph.waitAsync(syncParent);
2406                         waitAsyncProcedure(procedure);
2407
2408                 } else {
2409
2410 //                      Object syncParent = callerThread == Integer.MIN_VALUE ? null
2411 //                                      : request;
2412 //
2413 //                      final ReadGraphImpl newGraph = newSyncAsync(syncParent);
2414
2415                         try {
2416
2417 //                              inc();
2418 //                              ReadGraphImpl sync = newSync();
2419                                 request.perform(this, procedure);
2420 //                              sync.waitAsync(null);
2421                                 waitAsyncProcedure(procedure);
2422 //                              dec();
2423
2424                         } catch (Throwable t) {
2425
2426                                 waitAsyncProcedure(procedure);
2427 //                              dec();
2428
2429                         }
2430
2431                 }
2432
2433         }
2434
2435
2436         @Override
2437         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2438                         final AsyncMultiProcedure<T> procedure) {
2439
2440                 assert (request != null);
2441                 assert (procedure != null);
2442
2443                 ListenerBase listener = getListenerBase(procedure);
2444
2445                 if (parent != null || listener != null) {
2446
2447 //                      Object syncParent = request;
2448
2449 //                      final ReadGraphImpl newGraph = newSync();
2450
2451                         processor.query(this, request, parent, procedure, listener);
2452
2453 //                      newGraph.waitAsync(syncParent);
2454
2455                 } else {
2456
2457 //                      Object syncParent = request;
2458
2459 //                      final ReadGraphImpl newGraph = newSync();
2460
2461                         try {
2462
2463                                 request.perform(this, new AsyncMultiProcedure<T>() {
2464
2465                                         @Override
2466                                         public void execute(AsyncReadGraph graph, T result) {
2467                                                 procedure.execute(graph, result);
2468                                         }
2469
2470                                         @Override
2471                                         public void finished(AsyncReadGraph graph) {
2472                                                 procedure.finished(graph);
2473                                         }
2474
2475                                         @Override
2476                                         public void exception(AsyncReadGraph graph, Throwable t) {
2477                                                 procedure.exception(graph, t);
2478                                         }
2479
2480                                         @Override
2481                                         public String toString() {
2482                                                 return "syncRequest(AsyncMultiRead) -> " + procedure;
2483                                         }
2484
2485                                 });
2486
2487                         } catch (Throwable t) {
2488
2489                         }
2490
2491                 }
2492
2493                 // TODO!!
2494                 return null;
2495
2496         }
2497
2498         @Override
2499         public <T> Collection<T> syncRequest(AsyncMultiRead<T> request,
2500                         final SyncMultiProcedure<T> procedure) {
2501                 return syncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
2502         }
2503
2504         @Override
2505         final public <T> Collection<T> syncRequest(final AsyncMultiRead<T> request,
2506                         final MultiProcedure<T> procedure) {
2507                 return syncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
2508         }
2509
2510         @Override
2511         public <T> T syncRequest(final ExternalRead<T> request)
2512                         throws DatabaseException {
2513
2514                 assert (request != null);
2515
2516                 return syncRequest(request, new Procedure<T>() {
2517
2518                         @Override
2519                         public void execute(T t) {
2520                         }
2521
2522                         @Override
2523                         public void exception(Throwable t) {
2524                         }
2525
2526                         @Override
2527                         public String toString() {
2528                                 return "syncRequest(AsyncRead) -> " + request;
2529                         }
2530
2531                 });
2532
2533         }
2534
2535         @Override
2536         public <T> T syncRequest(ExternalRead<T> request, Listener<T> procedure) throws DatabaseException {
2537                 return syncRequest(request, (Procedure<T>) procedure);
2538         }
2539
2540         @Override
2541         final public <T> T syncRequest(final ExternalRead<T> request,
2542                         final Procedure<T> procedure) throws DatabaseException {
2543
2544                 assert (request != null);
2545
2546                 ListenerBase listener = getListenerBase(procedure);
2547
2548                 final DataContainer<Throwable> exception = new DataContainer<Throwable>();
2549                 final DataContainer<T> result = new DataContainer<T>();
2550
2551                 processor.query(this, request, parent, new Procedure<T>() {
2552
2553                         @Override
2554                         public void exception(Throwable throwable) {
2555                                 exception.set(throwable);
2556                                 procedure.exception(throwable);
2557                         }
2558
2559                         @Override
2560                         public void execute(T t) {
2561                                 result.set(t);
2562                                 procedure.execute(t);
2563                         }
2564
2565                 }, listener);
2566
2567
2568
2569 //              if (parent != null || listener != null) {
2570 //
2571 ////                    final ReadGraphImpl newGraph = newSync();
2572 //
2573 //
2574 ////                    newGraph.waitAsync(request);
2575 //
2576 //              } else {
2577 //
2578 //                      try {
2579 //
2580 //                              T t = processor.tryQuery(this, request);
2581 //                              result.set(t);
2582 //                              procedure.execute(t);
2583 //
2584 //                      } catch (Throwable t) {
2585 //
2586 //                          if (t instanceof DatabaseException) {
2587 //                              exception.set((DatabaseException)t);
2588 //                              procedure.exception(exception.get());
2589 //                          } else {
2590 //                              exception.set(new DatabaseException(
2591 //                                      "Unexpected exception in ReadGraph.syncRequest(Read)",
2592 //                                      t));
2593 //                              procedure.exception(exception.get());
2594 //                          }
2595 //
2596 //                      }
2597 //
2598 //              }
2599
2600                 Throwable t = exception.get();
2601                 if (t != null) {
2602                         if (t instanceof DatabaseException)
2603                                 throw (DatabaseException) t;
2604                         else
2605                                 throw new DatabaseException(
2606                                                 "Unexpected exception in ReadGraph.syncRequest(Read)",
2607                                                 t);
2608                 }
2609
2610                 return result.get();
2611
2612         }
2613
2614         @Override
2615         public void syncRequest(final Write request) throws DatabaseException {
2616
2617                 assert (request != null);
2618
2619                 throw new DatabaseException(
2620                                 "Write operations are not supported during read transactions!");
2621
2622         }
2623
2624         @Override
2625         public <T> T syncRequest(final WriteResult<T> request) throws DatabaseException {
2626
2627                 assert (request != null);
2628
2629                 throw new DatabaseException(
2630                                 "Write operations are not supported during read transactions!");
2631
2632         }
2633
2634         @Override
2635         public void syncRequest(final DelayedWrite request)
2636                         throws DatabaseException {
2637
2638                 assert (request != null);
2639
2640                 throw new DatabaseException(
2641                                 "Write operations are not supported during read transactions!");
2642
2643         }
2644
2645         @Override
2646         public <T> T syncRequest(final DelayedWriteResult<T> request) throws DatabaseException {
2647
2648                 assert (request != null);
2649
2650                 throw new DatabaseException(
2651                                 "Write operations are not supported during read transactions!");
2652
2653         }
2654
2655         @Override
2656         public void syncRequest(final WriteOnly request) throws DatabaseException {
2657
2658                 assert (request != null);
2659
2660                 throw new DatabaseException(
2661                                 "Write operations are not supported during read transactions!");
2662
2663         }
2664
2665         @Override
2666         public <T> T syncRequest(final WriteOnlyResult<T> request) throws DatabaseException {
2667
2668                 assert (request != null);
2669
2670                 throw new DatabaseException(
2671                                 "Write operations are not supported during read transactions!");
2672
2673         }
2674
2675         @Override
2676         public <T> void async(ReadInterface<T> r, AsyncProcedure<T> procedure) {
2677                 r.request(this, procedure);
2678         }
2679
2680         @Override
2681         public <T> void async(ReadInterface<T> r, Procedure<T> procedure) {
2682                 r.request(this, procedure);
2683         }
2684
2685         @Override
2686         public <T> void async(ReadInterface<T> r, SyncProcedure<T> procedure) {
2687                 r.request(this, procedure);
2688         }
2689
2690         @Override
2691         public <T> void async(ReadInterface<T> r, AsyncListener<T> procedure) {
2692                 r.request(this, procedure);
2693         }
2694
2695         @Override
2696         public <T> void async(ReadInterface<T> r, Listener<T> procedure) {
2697                 r.request(this, procedure);
2698         }
2699
2700         @Override
2701         public <T> void async(ReadInterface<T> r, SyncListener<T> procedure) {
2702                 r.request(this, procedure);
2703         }
2704
2705         @Override
2706         public <T> T sync(ReadInterface<T> r) throws DatabaseException {
2707                 return r.request(this);
2708         }
2709
2710         @Override
2711         public <T> T sync(WriteInterface<T> r) throws DatabaseException {
2712                 return r.request(this);
2713         }
2714
2715         @Override
2716         public <T> void async(WriteInterface<T> r, Procedure<T> procedure) {
2717                 r.request(this, procedure);
2718         }
2719
2720         @Override
2721         public <T> void async(WriteInterface<T> r) {
2722                 r.request(this, new ProcedureAdapter<T>());
2723         }
2724
2725         /*
2726          * Implementation of the interface AsyncReadGraph
2727          */
2728
2729         @Override
2730         public void forURI(Resource resource, AsyncListener<String> listener) {
2731                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2732                                 listener);
2733         }
2734
2735         @Override
2736         public void forURI(Resource resource, SyncListener<String> listener) {
2737                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2738                                 listener);
2739         }
2740
2741         @Override
2742         public void forURI(Resource resource, Listener<String> listener) {
2743                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2744                                 listener);
2745         }
2746
2747         @Override
2748         final public void forURI(final Resource resource,
2749                         final AsyncProcedure<String> procedure) {
2750
2751                 assert (resource != null);
2752                 assert (procedure != null);
2753
2754                 asyncRequest(new org.simantics.db.common.uri.ResourceToURI(resource),
2755                                 procedure);
2756
2757         }
2758
2759         @Override
2760         public void forURI(Resource resource, SyncProcedure<String> procedure) {
2761                 forURI(resource, new SyncToAsyncProcedure<String>(procedure));
2762         }
2763
2764         @Override
2765         public void forURI(Resource resource, Procedure<String> procedure) {
2766                 forURI(resource, new NoneToAsyncProcedure<String>(procedure));
2767         }
2768
2769         @Override
2770         public void forResource(String id, AsyncListener<Resource> listener) {
2771                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2772                                 listener);
2773         }
2774
2775         @Override
2776         public void forResource(String id, SyncListener<Resource> listener) {
2777                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2778                                 listener);
2779         }
2780
2781         @Override
2782         public void forResource(String id, Listener<Resource> listener) {
2783                 asyncRequest(new org.simantics.db.common.primitiverequest.Resource(id),
2784                                 listener);
2785         }
2786
2787         @Override
2788         final public void forResource(final String id,
2789                         final AsyncProcedure<Resource> procedure) {
2790
2791                 assert (id != null);
2792                 assert (procedure != null);
2793
2794                 processor.forResource(this, id, procedure);
2795
2796         }
2797
2798         @Override
2799         public void forResource(String id, SyncProcedure<Resource> procedure) {
2800                 forResource(id, new SyncToAsyncProcedure<Resource>(procedure));
2801         }
2802
2803         @Override
2804         public void forResource(String id, Procedure<Resource> procedure) {
2805                 forResource(id, new NoneToAsyncProcedure<Resource>(procedure));
2806         }
2807
2808         @Override
2809         public void forBuiltin(String id, AsyncListener<Resource> listener) {
2810                 asyncRequest(new Builtin(id), listener);
2811         }
2812
2813         @Override
2814         public void forBuiltin(String id, SyncListener<Resource> listener) {
2815                 asyncRequest(new Builtin(id), listener);
2816         }
2817
2818         @Override
2819         public void forBuiltin(String id, Listener<Resource> listener) {
2820                 asyncRequest(new Builtin(id), listener);
2821         }
2822
2823         @Override
2824         final public void forBuiltin(final String id,
2825                         final AsyncProcedure<Resource> procedure) {
2826
2827                 assert (id != null);
2828                 assert (procedure != null);
2829
2830                 processor.forBuiltin(this, id, procedure);
2831
2832         }
2833
2834         @Override
2835         public void forBuiltin(String id, SyncProcedure<Resource> procedure) {
2836                 forBuiltin(id, new SyncToAsyncProcedure<Resource>(procedure));
2837         }
2838
2839         @Override
2840         public void forBuiltin(String id, Procedure<Resource> procedure) {
2841                 forBuiltin(id, new NoneToAsyncProcedure<Resource>(procedure));
2842         }
2843
2844         @Override
2845         final public void forEachStatement(Resource subject, Resource relation,
2846                         AsyncMultiProcedure<Statement> procedure) {
2847
2848                 assert (subject != null);
2849                 assert (relation != null);
2850                 assert (procedure != null);
2851
2852                 processor.forEachStatement(this, subject, relation, procedure);
2853
2854         }
2855
2856         @Override
2857         public void forEachStatement(Resource subject, Resource relation,
2858                         SyncMultiProcedure<Statement> procedure) {
2859                 forEachStatement(subject, relation,
2860                                 new SyncToAsyncMultiProcedure<Statement>(procedure));
2861         }
2862
2863         @Override
2864         final public void forEachStatement(Resource subject, Resource relation,
2865                         MultiProcedure<Statement> procedure) {
2866
2867                 assert (subject != null);
2868                 assert (relation != null);
2869                 assert (procedure != null);
2870
2871                 processor.forEachStatement(this, subject, relation, procedure);
2872
2873         }
2874
2875         @Override
2876         final public void forStatementSet(Resource subject, Resource relation,
2877                         AsyncSetListener<Statement> procedure) {
2878
2879                 assert (subject != null);
2880                 assert (relation != null);
2881                 assert (procedure != null);
2882
2883                 processor.forStatementSet(this, subject, relation, procedure);
2884
2885         }
2886
2887         @Override
2888         final public void forStatementSet(Resource subject, Resource relation,
2889                         SyncSetListener<Statement> procedure) {
2890                 forStatementSet(subject, relation,
2891                                 new SyncToAsyncSetProcedure<Statement>(procedure));
2892         }
2893
2894         @Override
2895         public void forStatementSet(Resource subject, Resource relation,
2896                         SetListener<Statement> listener) {
2897                 forStatementSet(subject, relation,
2898                                 new NoneToAsyncSetProcedure<Statement>(listener));
2899         }
2900
2901         @Override
2902         final public void forEachAssertedStatement(final Resource subject,
2903                         final Resource relation,
2904                         final AsyncMultiProcedure<Statement> procedure) {
2905
2906                 assert (subject != null);
2907                 assert (relation != null);
2908                 assert (procedure != null);
2909
2910                 processor.forEachAssertedStatement(this, subject, relation, procedure);
2911
2912         }
2913
2914         @Override
2915         public void forEachAssertedStatement(Resource subject, Resource relation,
2916                         SyncMultiProcedure<Statement> procedure) {
2917                 forEachAssertedStatement(subject, relation,
2918                                 new SyncToAsyncMultiProcedure<Statement>(procedure));
2919         }
2920
2921         @Override
2922         public void forEachAssertedStatement(Resource subject, Resource relation,
2923                         MultiProcedure<Statement> procedure) {
2924                 forEachAssertedStatement(subject, relation,
2925                                 new NoneToAsyncMultiProcedure<Statement>(procedure));
2926         }
2927
2928         @Override
2929         public void forAssertedStatementSet(Resource subject, Resource relation,
2930                         AsyncSetListener<Statement> procedure) {
2931
2932                 assert (subject != null);
2933                 assert (relation != null);
2934                 assert (procedure != null);
2935
2936                 processor.forAssertedStatementSet(this, subject, relation, procedure);
2937
2938         }
2939
2940         @Override
2941         public void forAssertedStatementSet(Resource subject, Resource relation,
2942                         SyncSetListener<Statement> procedure) {
2943
2944                 assert (subject != null);
2945                 assert (relation != null);
2946                 assert (procedure != null);
2947
2948                 forAssertedStatementSet(subject, relation,
2949                                 new SyncToAsyncSetProcedure<Statement>(procedure));
2950
2951         }
2952
2953         @Override
2954         public void forAssertedStatementSet(Resource subject, Resource relation,
2955                         SetListener<Statement> procedure) {
2956
2957                 assert (subject != null);
2958                 assert (relation != null);
2959                 assert (procedure != null);
2960
2961                 forAssertedStatementSet(subject, relation,
2962                                 new NoneToAsyncSetProcedure<Statement>(procedure));
2963
2964         }
2965
2966         @Override
2967         final public void forEachPredicate(final Resource subject,
2968                         final AsyncMultiProcedure<Resource> procedure) {
2969
2970                 assert (subject != null);
2971                 assert (procedure != null);
2972
2973                 processor.forEachPredicate(this, subject, procedure);
2974
2975         }
2976
2977         @Override
2978         public void forEachPredicate(Resource subject,
2979                         SyncMultiProcedure<Resource> procedure) {
2980                 forEachPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(
2981                                 procedure));
2982         }
2983
2984         @Override
2985         final public void forEachPredicate(final Resource subject,
2986                         final MultiProcedure<Resource> procedure) {
2987
2988                 assert (subject != null);
2989                 assert (procedure != null);
2990
2991                 processor.forEachPredicate(this, subject, procedure);
2992
2993         }
2994
2995         @Override
2996         final public void forPredicateSet(final Resource subject,
2997                         final AsyncSetListener<Resource> procedure) {
2998
2999                 assert (subject != null);
3000                 assert (procedure != null);
3001
3002                 processor.forPredicateSet(this, subject, procedure);
3003
3004         }
3005
3006         @Override
3007         final public void forPredicateSet(final Resource subject,
3008                         final SyncSetListener<Resource> procedure) {
3009
3010                 assert (subject != null);
3011                 assert (procedure != null);
3012
3013                 forPredicateSet(subject, new SyncToAsyncSetProcedure<Resource>(
3014                                 procedure));
3015
3016         }
3017
3018         @Override
3019         final public void forPredicateSet(final Resource subject,
3020                         final SetListener<Resource> procedure) {
3021
3022                 assert (subject != null);
3023                 assert (procedure != null);
3024
3025                 forPredicateSet(subject, new NoneToAsyncSetProcedure<Resource>(
3026                                 procedure));
3027
3028         }
3029
3030         @Override
3031         final public void forEachPrincipalType(final Resource subject,
3032                         final AsyncMultiProcedure<Resource> procedure) {
3033
3034                 assert (subject != null);
3035                 assert (procedure != null);
3036
3037                 processor.forEachPrincipalType(this, subject, procedure);
3038
3039         }
3040
3041         @Override
3042         public void forEachPrincipalType(Resource subject,
3043                         SyncMultiProcedure<Resource> procedure) {
3044                 forEachPrincipalType(subject, new SyncToAsyncMultiProcedure<Resource>(
3045                                 procedure));
3046         }
3047
3048         @Override
3049         final public void forEachPrincipalType(final Resource subject,
3050                         final MultiProcedure<Resource> procedure) {
3051
3052                 assert (subject != null);
3053                 assert (procedure != null);
3054
3055                 processor.forEachPrincipalType(this, subject, procedure);
3056
3057         }
3058
3059         @Override
3060         final public void forPrincipalTypeSet(final Resource subject,
3061                         final AsyncSetListener<Resource> procedure) {
3062
3063                 assert (subject != null);
3064                 assert (procedure != null);
3065
3066                 processor.forPrincipalTypeSet(this, subject, procedure);
3067
3068         }
3069
3070         @Override
3071         final public void forPrincipalTypeSet(final Resource subject,
3072                         final SyncSetListener<Resource> procedure) {
3073
3074                 assert (subject != null);
3075                 assert (procedure != null);
3076
3077                 forPrincipalTypeSet(subject, new SyncToAsyncSetProcedure<Resource>(
3078                                 procedure));
3079
3080         }
3081
3082         @Override
3083         final public void forPrincipalTypeSet(final Resource subject,
3084                         final SetListener<Resource> procedure) {
3085
3086                 assert (subject != null);
3087                 assert (procedure != null);
3088
3089                 forPrincipalTypeSet(subject, new NoneToAsyncSetProcedure<Resource>(
3090                                 procedure));
3091
3092         }
3093
3094         @Override
3095         public void forTypes(Resource subject, AsyncListener<Set<Resource>> listener) {
3096                 asyncRequest(new Types(subject), listener);
3097         }
3098
3099         @Override
3100         public void forTypes(Resource subject, SyncListener<Set<Resource>> listener) {
3101                 asyncRequest(new Types(subject), listener);
3102         }
3103
3104         @Override
3105         public void forTypes(Resource subject, Listener<Set<Resource>> listener) {
3106                 asyncRequest(new Types(subject), listener);
3107         }
3108
3109         @Override
3110         final public void forTypes(final Resource subject,
3111                         final AsyncProcedure<Set<Resource>> procedure) {
3112
3113                 assert (subject != null);
3114                 assert (procedure != null);
3115
3116                 processor.forTypes(this, subject, procedure);
3117
3118         }
3119
3120         @Override
3121         public void forTypes(Resource subject,
3122                         SyncProcedure<Set<Resource>> procedure) {
3123                 forTypes(subject, new SyncToAsyncProcedure<Set<Resource>>(procedure));
3124         }
3125
3126         @Override
3127         public void forTypes(Resource subject, Procedure<Set<Resource>> procedure) {
3128                 forTypes(subject, new NoneToAsyncProcedure<Set<Resource>>(procedure));
3129         }
3130
3131         @Override
3132         public void forSupertypes(Resource subject,
3133                         AsyncListener<Set<Resource>> listener) {
3134                 asyncRequest(new Types(subject), listener);
3135         }
3136
3137         @Override
3138         public void forSupertypes(Resource subject,
3139                         SyncListener<Set<Resource>> listener) {
3140                 asyncRequest(new Types(subject), listener);
3141         }
3142
3143         @Override
3144         public void forSupertypes(Resource subject, Listener<Set<Resource>> listener) {
3145                 asyncRequest(new Types(subject), listener);
3146         }
3147
3148         @Override
3149         final public void forSupertypes(final Resource subject,
3150                         final AsyncProcedure<Set<Resource>> procedure) {
3151
3152                 assert (subject != null);
3153                 assert (procedure != null);
3154
3155                 processor.forSupertypes(this, subject, procedure);
3156
3157         }
3158
3159         @Override
3160         public void forSupertypes(Resource subject,
3161                         SyncProcedure<Set<Resource>> procedure) {
3162                 forSupertypes(subject, new SyncToAsyncProcedure<Set<Resource>>(
3163                                 procedure));
3164         }
3165
3166         @Override
3167         public void forSupertypes(Resource subject,
3168                         Procedure<Set<Resource>> procedure) {
3169                 forSupertypes(subject, new NoneToAsyncProcedure<Set<Resource>>(
3170                                 procedure));
3171         }
3172
3173         @Override
3174         public void forDirectSuperrelations(Resource subject,
3175                         AsyncMultiProcedure<Resource> procedure) {
3176
3177                 assert (subject != null);
3178                 assert (procedure != null);
3179
3180                 processor.forDirectSuperrelations(this, subject, procedure);
3181
3182         }
3183
3184         @Override
3185         public void forPossibleSuperrelation(Resource subject, AsyncProcedure<Resource> procedure) {
3186
3187                 assert (subject != null);
3188                 assert (procedure != null);
3189
3190                 processor.forPossibleSuperrelation(this, subject, procedure);
3191
3192         }
3193
3194         @Override
3195         public void forSuperrelations(Resource subject,
3196                         AsyncListener<Set<Resource>> listener) {
3197                 asyncRequest(new Types(subject), listener);
3198         }
3199
3200         @Override
3201         public void forSuperrelations(Resource subject,
3202                         SyncListener<Set<Resource>> listener) {
3203                 asyncRequest(new Types(subject), listener);
3204         }
3205
3206         @Override
3207         public void forSuperrelations(Resource subject,
3208                         Listener<Set<Resource>> listener) {
3209                 asyncRequest(new Types(subject), listener);
3210         }
3211
3212         @Override
3213         final public void forSuperrelations(final Resource subject,
3214                         final AsyncProcedure<Set<Resource>> procedure) {
3215
3216                 assert (subject != null);
3217                 assert (procedure != null);
3218
3219                 processor.forSuperrelations(this, subject, procedure);
3220
3221         }
3222
3223         @Override
3224         public void forSuperrelations(Resource subject,
3225                         SyncProcedure<Set<Resource>> procedure) {
3226                 forSuperrelations(subject, new SyncToAsyncProcedure<Set<Resource>>(
3227                                 procedure));
3228         }
3229
3230         @Override
3231         public void forSuperrelations(Resource subject,
3232                         Procedure<Set<Resource>> procedure) {
3233                 forSuperrelations(subject, new NoneToAsyncProcedure<Set<Resource>>(
3234                                 procedure));
3235         }
3236
3237         @Override
3238         final public void forEachObject(final Resource subject, final Resource relation, final AsyncMultiProcedure<Resource> procedure) {
3239                 processor.forEachObject(this, subject, relation, procedure);
3240         }
3241
3242         @Override
3243         public void forEachObject(Resource subject, Resource relation,
3244                         SyncMultiProcedure<Resource> procedure) {
3245                 forEachObject(subject, relation,
3246                                 new SyncToAsyncMultiProcedure<Resource>(procedure));
3247         }
3248
3249         @Override
3250         public void forEachObject(Resource subject, Resource relation,
3251                         MultiProcedure<Resource> procedure) {
3252
3253                 processor.forEachObject(this, subject, relation, procedure);
3254
3255         }
3256
3257 //      @Override
3258 //      final public void forEachDirectObject(final Resource subject,
3259 //                      final Resource relation,
3260 //                      final AsyncMultiProcedure<Resource> procedure) {
3261 //
3262 //              processor.forEachDirectObject(this, subject, relation, procedure);
3263 //
3264 //      }
3265 //
3266 //      @Override
3267 //      public void forEachDirectObject(Resource subject, Resource relation,
3268 //                      SyncMultiProcedure<Resource> procedure) {
3269 //              forEachDirectObject(subject, relation,
3270 //                              new SyncToAsyncMultiProcedure<Resource>(procedure));
3271 //      }
3272 //
3273 //      @Override
3274 //      public void forEachDirectObject(Resource subject, Resource relation,
3275 //                      MultiProcedure<Resource> procedure) {
3276 //              forEachDirectObject(subject, relation,
3277 //                              new NoneToAsyncMultiProcedure<Resource>(procedure));
3278 //      }
3279
3280         @Override
3281         final public void forEachDirectPredicate(final Resource subject, final AsyncMultiProcedure<Resource> procedure) {
3282                 processor.forEachDirectPredicate(this, subject, procedure);
3283         }
3284
3285         @Override
3286         public void forEachDirectPredicate(Resource subject, SyncMultiProcedure<Resource> procedure) {
3287                 forEachDirectPredicate(subject, new SyncToAsyncMultiProcedure<Resource>(procedure));
3288         }
3289
3290         @Override
3291         public void forEachDirectPredicate(Resource subject, MultiProcedure<Resource> procedure) {
3292                 forEachDirectPredicate(subject, new NoneToAsyncMultiProcedure<Resource>(procedure));
3293         }
3294
3295         @Override
3296         final public void forObjectSet(final Resource subject,
3297                         final Resource relation, final AsyncSetListener<Resource> procedure) {
3298
3299                 assert (subject != null);
3300                 assert (relation != null);
3301                 assert (procedure != null);
3302
3303                 processor.forObjectSet(this, subject, relation, procedure);
3304
3305         }
3306
3307         @Override
3308         final public void forObjectSet(final Resource subject,
3309                         final Resource relation, final SyncSetListener<Resource> procedure) {
3310
3311                 assert (subject != null);
3312                 assert (relation != null);
3313                 assert (procedure != null);
3314
3315                 forObjectSet(subject, relation, new SyncToAsyncSetProcedure<Resource>(
3316                                 procedure));
3317
3318         }
3319
3320         @Override
3321         final public void forObjectSet(final Resource subject,
3322                         final Resource relation, final SetListener<Resource> procedure) {
3323
3324                 assert (subject != null);
3325                 assert (relation != null);
3326                 assert (procedure != null);
3327
3328                 forObjectSet(subject, relation, new NoneToAsyncSetProcedure<Resource>(
3329                                 procedure));
3330
3331         }
3332
3333         @Override
3334         final public void forEachAssertedObject(final Resource subject,
3335                         final Resource relation,
3336                         final AsyncMultiProcedure<Resource> procedure) {
3337
3338                 assert (subject != null);
3339                 assert (relation != null);
3340                 assert (procedure != null);
3341
3342                 processor.forEachAssertedObject(this, subject, relation, procedure);
3343
3344         }
3345
3346         @Override
3347         public void forEachAssertedObject(Resource subject, Resource relation,
3348                         SyncMultiProcedure<Resource> procedure) {
3349
3350                 assert (subject != null);
3351                 assert (relation != null);
3352                 assert (procedure != null);
3353
3354                 forEachAssertedObject(subject, relation,
3355                                 new SyncToAsyncMultiProcedure<Resource>(procedure));
3356
3357         }
3358
3359         @Override
3360         public void forEachAssertedObject(Resource subject, Resource relation,
3361                         MultiProcedure<Resource> procedure) {
3362
3363                 assert (subject != null);
3364                 assert (relation != null);
3365                 assert (procedure != null);
3366
3367                 forEachAssertedObject(subject, relation,
3368                                 new NoneToAsyncMultiProcedure<Resource>(procedure));
3369
3370         }
3371
3372         @Override
3373         public void forAssertedObjectSet(Resource subject, Resource relation,
3374                         AsyncSetListener<Resource> procedure) {
3375
3376                 assert (subject != null);
3377                 assert (relation != null);
3378                 assert (procedure != null);
3379
3380                 processor.forAssertedObjectSet(this, subject, relation, procedure);
3381
3382         }
3383
3384         @Override
3385         public void forAssertedObjectSet(Resource subject, Resource relation,
3386                         SyncSetListener<Resource> procedure) {
3387
3388                 assert (subject != null);
3389                 assert (relation != null);
3390                 assert (procedure != null);
3391
3392                 forAssertedObjectSet(subject, relation,
3393                                 new SyncToAsyncSetProcedure<Resource>(procedure));
3394
3395         }
3396
3397         @Override
3398         public void forAssertedObjectSet(Resource subject, Resource relation,
3399                         SetListener<Resource> procedure) {
3400
3401                 assert (subject != null);
3402                 assert (relation != null);
3403                 assert (procedure != null);
3404
3405                 forAssertedObjectSet(subject, relation,
3406                                 new NoneToAsyncSetProcedure<Resource>(procedure));
3407
3408         }
3409
3410         @Override
3411         public void forInverse(Resource relation, AsyncListener<Resource> listener) {
3412                 asyncRequest(new Inverse(relation), listener);
3413         }
3414
3415         @Override
3416         public void forInverse(Resource relation, SyncListener<Resource> listener) {
3417                 asyncRequest(new Inverse(relation), listener);
3418         }
3419
3420         @Override
3421         public void forInverse(Resource relation, Listener<Resource> listener) {
3422                 asyncRequest(new Inverse(relation), listener);
3423         }
3424
3425         @Override
3426         final public void forInverse(final Resource relation,
3427                         final AsyncProcedure<Resource> procedure) {
3428
3429                 assert (relation != null);
3430                 assert (procedure != null);
3431
3432                 processor.forInverse(this, relation, new AsyncProcedure<Resource>() {
3433
3434                         @Override
3435                         public void execute(AsyncReadGraph graph, Resource result) {
3436                                 if (result != null)
3437                                         procedure.execute(graph, result);
3438                                 else {
3439                                         procedure.exception(graph, new NoInverseException(relation
3440                                                         .toString()));
3441                                 }
3442                         }
3443
3444                         @Override
3445                         public void exception(AsyncReadGraph graph, Throwable throwable) {
3446                                 procedure.exception(graph, throwable);
3447                         }
3448
3449                         @Override
3450                         public String toString() {
3451                                 return "forInverse -> " + procedure;
3452                         }
3453
3454                 });
3455
3456         }
3457
3458         @Override
3459         public void forInverse(Resource relation, SyncProcedure<Resource> procedure) {
3460                 forInverse(relation, new SyncToAsyncProcedure<Resource>(procedure));
3461         }
3462
3463         @Override
3464         public void forInverse(Resource relation, Procedure<Resource> procedure) {
3465                 forInverse(relation, new NoneToAsyncProcedure<Resource>(procedure));
3466         }
3467
3468         @Override
3469         public void forSingleObject(Resource subject, Resource relation,
3470                         AsyncListener<Resource> listener) {
3471                 asyncRequest(new SingleObject(subject, relation), listener);
3472         }
3473
3474         @Override
3475         public void forSingleObject(Resource subject, Resource relation,
3476                         SyncListener<Resource> listener) {
3477                 asyncRequest(new SingleObject(subject, relation), listener);
3478         }
3479
3480         @Override
3481         public void forSingleObject(Resource subject, Resource relation,
3482                         Listener<Resource> listener) {
3483                 asyncRequest(new SingleObject(subject, relation), listener);
3484         }
3485
3486         @Override
3487         final public void forSingleObject(final Resource subject,
3488                         final Resource relation, final AsyncProcedure<Resource> procedure) {
3489
3490                 assert (subject != null);
3491                 assert (relation != null);
3492                 assert (procedure != null);
3493
3494                 processor.forEachObject(this, subject, relation,
3495                                 new SingleOrErrorProcedure<Resource>(procedure));
3496
3497         }
3498
3499         @Override
3500         public void forSingleObject(Resource subject, Resource relation,
3501                         SyncProcedure<Resource> procedure) {
3502                 forSingleObject(subject, relation, new SyncToAsyncProcedure<Resource>(
3503                                 procedure));
3504         }
3505
3506         @Override
3507         public void forSingleObject(Resource subject, Resource relation,
3508                         Procedure<Resource> procedure) {
3509                 forSingleObject(subject, relation, new NoneToAsyncProcedure<Resource>(
3510                                 procedure));
3511         }
3512
3513         @Override
3514         public void forSingleStatement(Resource subject, Resource relation,
3515                         AsyncListener<Statement> listener) {
3516                 asyncRequest(new SingleStatement(subject, relation), listener);
3517         }
3518
3519         @Override
3520         public void forSingleStatement(Resource subject, Resource relation,
3521                         SyncListener<Statement> listener) {
3522                 asyncRequest(new SingleStatement(subject, relation), listener);
3523         }
3524
3525         @Override
3526         public void forSingleStatement(Resource subject, Resource relation,
3527                         Listener<Statement> listener) {
3528                 asyncRequest(new SingleStatement(subject, relation), listener);
3529         }
3530
3531         @Override
3532         final public void forSingleStatement(final Resource subject,
3533                         final Resource relation, final AsyncProcedure<Statement> procedure) {
3534
3535                 assert (subject != null);
3536                 assert (relation != null);
3537                 assert (procedure != null);
3538
3539                 processor.forEachStatement(this, subject, relation,
3540                                 new SingleOrErrorProcedure<Statement>(procedure));
3541
3542         }
3543
3544         @Override
3545         public void forSingleStatement(Resource subject, Resource relation,
3546                         SyncProcedure<Statement> procedure) {
3547                 forSingleStatement(subject, relation,
3548                                 new SyncToAsyncProcedure<Statement>(procedure));
3549         }
3550
3551         @Override
3552         public void forSingleStatement(Resource subject, Resource relation,
3553                         Procedure<Statement> procedure) {
3554                 forSingleStatement(subject, relation,
3555                                 new NoneToAsyncProcedure<Statement>(procedure));
3556         }
3557
3558         @Override
3559         public void forSingleType(Resource subject,
3560                         AsyncListener<Resource> listener) {
3561                 asyncRequest(new SingleTypeAny(subject), listener);
3562         }
3563
3564         @Override
3565         public void forSingleType(Resource subject,
3566                         SyncListener<Resource> listener) {
3567                 asyncRequest(new SingleTypeAny(subject), listener);
3568         }
3569
3570         @Override
3571         public void forSingleType(Resource subject,
3572                         Listener<Resource> listener) {
3573                 asyncRequest(new SingleTypeAny(subject), listener);
3574         }
3575
3576         @Override
3577         final public void forSingleType(final Resource subject, final AsyncProcedure<Resource> procedure) {
3578
3579                 assert (subject != null);
3580                 assert (procedure != null);
3581
3582                 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3583
3584                 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
3585
3586                         @Override
3587                         public void execute(AsyncReadGraph graph, final Resource principalType) {
3588                                 checkedProcedure.offer(graph, principalType);
3589                         }
3590
3591                         @Override
3592                         public void finished(AsyncReadGraph graph) {
3593                                 checkedProcedure.dec(graph);
3594                         }
3595
3596                         @Override
3597                         public void exception(AsyncReadGraph graph, Throwable t) {
3598                                 checkedProcedure.exception(graph, t);
3599                         }
3600
3601                         @Override
3602                         public String toString() {
3603                                 return "forSingleType -> " + procedure;
3604                         }
3605
3606                 });
3607
3608         }
3609
3610         @Override
3611         public void forSingleType(Resource subject, SyncProcedure<Resource> procedure) {
3612                 forSingleType(subject, new SyncToAsyncProcedure<Resource>(
3613                                 procedure));
3614         }
3615
3616         @Override
3617         public void forSingleType(Resource subject, Procedure<Resource> procedure) {
3618                 forSingleType(subject, new NoneToAsyncProcedure<Resource>(
3619                                 procedure));
3620         }
3621
3622         @Override
3623         public void forSingleType(Resource subject, Resource relation,
3624                         AsyncListener<Resource> listener) {
3625                 asyncRequest(new SingleType(subject, relation), listener);
3626         }
3627
3628         @Override
3629         public void forSingleType(Resource subject, Resource relation,
3630                         SyncListener<Resource> listener) {
3631                 asyncRequest(new SingleType(subject, relation), listener);
3632         }
3633
3634         @Override
3635         public void forSingleType(Resource subject, Resource relation,
3636                         Listener<Resource> listener) {
3637                 asyncRequest(new SingleType(subject, relation), listener);
3638         }
3639
3640         @Override
3641         final public void forSingleType(final Resource subject,
3642                         final Resource baseType, final AsyncProcedure<Resource> procedure) {
3643
3644                 assert (subject != null);
3645                 assert (procedure != null);
3646
3647                 final DeepSingleOrErrorProcedure<Resource> checkedProcedure = new DeepSingleOrErrorProcedure<Resource>(procedure);
3648
3649                 processor.forEachPrincipalType(this, subject,
3650                                 new AsyncMultiProcedureAdapter<Resource>() {
3651
3652                                         @Override
3653                                         public void execute(AsyncReadGraph graph,
3654                                                         final Resource principalType) {
3655
3656                                                 checkedProcedure.inc();
3657
3658                                                 if(baseType == null) {
3659
3660                                                         checkedProcedure.offer(graph, principalType);
3661                                                         checkedProcedure.dec(graph);
3662
3663                                                 } else if(principalType.equals(baseType)) {
3664
3665                                                         checkedProcedure.offer(graph, principalType);
3666                                                         checkedProcedure.dec(graph);
3667
3668                                                 } else {
3669
3670                                                         processor.forSupertypes((ReadGraphImpl)graph, principalType,
3671                                                                         new AsyncProcedure<Set<Resource>>() {
3672
3673                                                                                 @Override
3674                                                                                 public void execute(
3675                                                                                                 AsyncReadGraph graph,
3676                                                                                                 Set<Resource> result) {
3677
3678                                                                                         if (result.contains(baseType))
3679                                                                                                 checkedProcedure.offer(graph,
3680                                                                                                                 principalType);
3681                                                                                         checkedProcedure.dec(graph);
3682
3683                                                                                 }
3684
3685                                                                                 @Override
3686                                                                                 public void exception(
3687                                                                                                 AsyncReadGraph graph,
3688                                                                                                 Throwable t) {
3689                                                                                         checkedProcedure
3690                                                                                                         .exception(graph, t);
3691                                                                                 }
3692
3693                                                                         });
3694
3695                                                 }
3696
3697                                         }
3698
3699                                         @Override
3700                                         public void finished(AsyncReadGraph graph) {
3701                                                 checkedProcedure.dec(graph);
3702                                         }
3703
3704                                         @Override
3705                                         public void exception(AsyncReadGraph graph, Throwable t) {
3706                                                 checkedProcedure.exception(graph, t);
3707                                         }
3708
3709                                         @Override
3710                                         public String toString() {
3711                                                 return "forSingleType -> " + procedure;
3712                                         }
3713
3714                                 });
3715
3716         }
3717
3718         @Override
3719         public void forSingleType(Resource subject, Resource relation,
3720                         SyncProcedure<Resource> procedure) {
3721                 forSingleType(subject, relation, new SyncToAsyncProcedure<Resource>(
3722                                 procedure));
3723         }
3724
3725         @Override
3726         public void forSingleType(Resource subject, Resource relation,
3727                         Procedure<Resource> procedure) {
3728                 forSingleType(subject, relation, new NoneToAsyncProcedure<Resource>(
3729                                 procedure));
3730         }
3731
3732         @Override
3733         public <T> void forValue(Resource subject, Binding binding,
3734                         AsyncListener<T> listener) {
3735                 asyncRequest(new Value<T>(subject, binding), listener);
3736         }
3737
3738         @Override
3739         public <T> void forValue(Resource subject, Binding binding,
3740                         SyncListener<T> listener) {
3741                 asyncRequest(new Value<T>(subject, binding), listener);
3742         }
3743
3744         @Override
3745         public <T> void forValue(Resource subject, Binding binding,
3746                         Listener<T> listener) {
3747                 asyncRequest(new Value<T>(subject, binding), listener);
3748         }
3749
3750         @Override
3751         public <T> void forValue(final Resource resource, final Binding binding,
3752                         final AsyncProcedure<T> procedure) {
3753
3754                 assert (resource != null);
3755                 assert (binding != null);
3756                 assert (procedure != null);
3757
3758                 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
3759
3760                         @Override
3761                         public void execute(AsyncReadGraph graph, byte[] result) {
3762
3763                                 try {
3764
3765                                         if (result == null) {
3766                                                 procedure.exception(graph,
3767                                                                 new DoesNotContainValueException(
3768                                                                                 "No value for resource " + resource));
3769                                                 return;
3770                                         }
3771
3772                                         Serializer serializer = binding.serializer();
3773 //                                      Serializer serializer = Bindings.getSerializer( binding );
3774                                         Object obj = serializer.deserialize(result);
3775 //                                      if (!binding.isInstance(obj))
3776 //                                              procedure.exception(graph, new ClassCastException(
3777 //                                                              "Cannot get value " + obj + " with binding "
3778 //                                                                              + binding));
3779 //                                      else
3780                                                 procedure.execute(graph, (T) obj);
3781
3782                                 } catch (IOException e) {
3783                                         procedure.exception(graph, e);
3784                                 } catch (BufferUnderflowException e) {
3785                                         procedure.exception(graph, e);
3786                                 } catch (Throwable t) {
3787                                         procedure.exception(graph, t);
3788                                 }
3789
3790                         }
3791
3792                         @Override
3793                         public void exception(AsyncReadGraph graph, Throwable t) {
3794                                 try {
3795                                         procedure.exception(graph, t);
3796                                 } catch (Throwable t2) {
3797                                 Logger.defaultLogError(t2);
3798                                 }
3799                         }
3800
3801                         @Override
3802                         public String toString() {
3803                                 return "forValue -> " + procedure;
3804                         }
3805
3806                 });
3807
3808         }
3809
3810         @Override
3811         public <T> void forValue(Resource subject, Binding binding,
3812                         SyncProcedure<T> procedure) {
3813                 forValue(subject, binding, new SyncToAsyncProcedure<T>(procedure));
3814         }
3815
3816         @Override
3817         public <T> void forValue(Resource subject, Binding binding,
3818                         Procedure<T> procedure) {
3819                 forValue(subject, binding, new NoneToAsyncProcedure<T>(procedure));
3820         }
3821
3822         @Override
3823         public <T> void forValue(Resource subject, AsyncListener<T> listener) {
3824                 asyncRequest(new ValueImplied<T>(subject), listener);
3825         }
3826
3827         @Override
3828         public <T> void forValue(Resource subject, SyncListener<T> listener) {
3829                 asyncRequest(new ValueImplied<T>(subject), listener);
3830         }
3831
3832         @Override
3833         public <T> void forValue(Resource subject, Listener<T> listener) {
3834                 asyncRequest(new ValueImplied<T>(subject), listener);
3835         }
3836
3837         @Override
3838         final public <T> void forValue(final Resource subject, final AsyncProcedure<T> procedure) {
3839
3840                 assert (subject != null);
3841                 assert (procedure != null);
3842
3843                 forRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
3844
3845                         @Override
3846                         public void execute(AsyncReadGraph graph, Datatype type) {
3847                                 // TODO: consider trying Bindings.getBeanBinding(type);
3848                                 Binding binding = Bindings.getBinding(type);
3849                                 graph.forValue(subject, binding, procedure);
3850                         }
3851
3852                         @Override
3853                         public void exception(AsyncReadGraph graph, Throwable throwable) {
3854                                 procedure.exception(graph, new DoesNotContainValueException("Invalid data type", throwable));
3855                         }
3856
3857                 });
3858
3859         }
3860
3861         @Override
3862         public <T> void forValue(Resource subject, SyncProcedure<T> procedure) {
3863                 forValue(subject, new SyncToAsyncProcedure<T>(procedure));
3864         }
3865
3866         @Override
3867         public <T> void forValue(Resource subject, Procedure<T> procedure) {
3868                 forValue(subject, new NoneToAsyncProcedure<T>(procedure));
3869         }
3870
3871         @Override
3872         public <T> void forRelatedValue(Resource subject, Resource relation,
3873                         AsyncListener<T> listener) {
3874                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3875         }
3876
3877         @Override
3878         public <T> void forRelatedValue(Resource subject, Resource relation,
3879                         SyncListener<T> listener) {
3880                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3881         }
3882
3883         @Override
3884         public <T> void forRelatedValue(Resource subject, Resource relation,
3885                         Listener<T> listener) {
3886                 asyncRequest(new RelatedValueImplied<T>(subject, relation), listener);
3887         }
3888
3889         @Override
3890         final public <T> void forRelatedValue(final Resource subject,
3891                         final Resource relation, final AsyncProcedure<T> procedure) {
3892
3893                 assert (subject != null);
3894                 assert (relation != null);
3895                 assert (procedure != null);
3896
3897                 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3898
3899                 processor.forEachObject(this, subject, relation,
3900                                 new AsyncMultiProcedureAdapter<Resource>() {
3901
3902                                         @Override
3903                                         public void execute(AsyncReadGraph graph,
3904                                                         final Resource object) {
3905
3906                                                 checkedProcedure.inc();
3907
3908                                                 graph.forValue(object, new AsyncProcedure<Object>() {
3909
3910                                                         @Override
3911                                                         public void execute(AsyncReadGraph graph,
3912                                                                         Object result) {
3913                                                                 checkedProcedure.offer(graph, (T) result);
3914                                                                 checkedProcedure.dec(graph);
3915                                                         }
3916
3917                                                         @Override
3918                                                         public void exception(AsyncReadGraph graph,
3919                                                                         Throwable t) {
3920                                                                 checkedProcedure.exception(graph, t);
3921                                                         }
3922
3923                                                         @Override
3924                                                         public String toString() {
3925                                                                 return "forRelatedValue -> " + procedure;
3926                                                         }
3927
3928                                                 });
3929
3930                                         }
3931
3932                                         @Override
3933                                         public void finished(AsyncReadGraph graph) {
3934                                                 checkedProcedure.dec(graph);
3935                                         }
3936
3937                                         @Override
3938                                         public void exception(AsyncReadGraph graph, Throwable t) {
3939                                                 checkedProcedure.exception(graph, t);
3940                                         }
3941
3942                                 });
3943
3944         }
3945
3946         @Override
3947         public <T> void forRelatedValue(Resource subject, Resource relation,
3948                         SyncProcedure<T> procedure) {
3949                 forRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
3950                                 procedure));
3951         }
3952
3953         @Override
3954         public <T> void forRelatedValue(Resource subject, Resource relation,
3955                         Procedure<T> procedure) {
3956                 forRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
3957                                 procedure));
3958         }
3959
3960         @Override
3961         public <T> void forRelatedValue(Resource subject, Resource relation,
3962                         Binding binding, AsyncListener<T> listener) {
3963                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3964         }
3965
3966         @Override
3967         public <T> void forRelatedValue(Resource subject, Resource relation,
3968                         Binding binding, SyncListener<T> listener) {
3969                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3970         }
3971
3972         @Override
3973         public <T> void forRelatedValue(Resource subject, Resource relation,
3974                         Binding binding, Listener<T> listener) {
3975                 asyncRequest(new RelatedValue<T>(subject, relation, binding), listener);
3976         }
3977
3978         @Override
3979         final public <T> void forRelatedValue(final Resource subject,
3980                         final Resource relation, final Binding binding,
3981                         final AsyncProcedure<T> procedure) {
3982
3983                 assert (subject != null);
3984                 assert (relation != null);
3985                 assert (binding != null);
3986                 assert (procedure != null);
3987
3988                 final DeepSingleOrErrorProcedure<T> checkedProcedure = new DeepSingleOrErrorProcedure<T>(procedure);
3989
3990                 processor.forEachObject(this, subject, relation,
3991                                 new AsyncMultiProcedureAdapter<Resource>() {
3992
3993                                         @Override
3994                                         public void execute(AsyncReadGraph graph,
3995                                                         final Resource object) {
3996
3997                                                 checkedProcedure.inc();
3998
3999                                                 graph.forValue(object, binding, new AsyncProcedure<Object>() {
4000
4001                                                                         @Override
4002                                                                         public void execute(AsyncReadGraph graph,
4003                                                                                         Object result) {
4004
4005                                                                                 checkedProcedure.offer(graph,
4006                                                                                                 (T) result);
4007                                                                                 checkedProcedure.dec(graph);
4008                                                                         }
4009
4010                                                                         @Override
4011                                                                         public void exception(AsyncReadGraph graph,
4012                                                                                         Throwable t) {
4013                                                                                 checkedProcedure.exception(graph, t);
4014                                                                         }
4015
4016                                                                         @Override
4017                                                                         public String toString() {
4018                                                                                 return "forRelatedValue -> "
4019                                                                                                 + procedure;
4020                                                                         }
4021
4022                                                                 });
4023
4024                                         }
4025
4026                                         @Override
4027                                         public void finished(AsyncReadGraph graph) {
4028                                                 checkedProcedure.dec(graph);
4029                                         }
4030
4031                                         @Override
4032                                         public void exception(AsyncReadGraph graph, Throwable t) {
4033                                                 checkedProcedure.exception(graph, t);
4034                                         }
4035
4036                                 });
4037
4038         }
4039
4040         @Override
4041         public <T> void forRelatedValue(Resource subject, Resource relation,
4042                         Binding binding, SyncProcedure<T> procedure) {
4043                 forRelatedValue(subject, relation, binding,
4044                                 new SyncToAsyncProcedure<T>(procedure));
4045         }
4046
4047         @Override
4048         public <T> void forRelatedValue(Resource subject, Resource relation,
4049                         Binding binding, Procedure<T> procedure) {
4050                 forRelatedValue(subject, relation, binding,
4051                                 new NoneToAsyncProcedure<T>(procedure));
4052         }
4053
4054         @Override
4055         public <T> void forAdapted(Resource resource, Class<T> clazz,
4056                         AsyncListener<T> listener) {
4057                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4058         }
4059
4060         @Override
4061         public <T> void forAdapted(Resource resource, Class<T> clazz,
4062                         SyncListener<T> listener) {
4063                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4064         }
4065
4066         @Override
4067         public <T> void forAdapted(Resource resource, Class<T> clazz,
4068                         Listener<T> listener) {
4069                 asyncRequest(new Adapter<T>(resource, clazz), listener);
4070         }
4071
4072         @Override
4073         final public <T> void forAdapted(final Resource resource,
4074                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
4075
4076                 assert (resource != null);
4077                 assert (clazz != null);
4078                 assert (procedure != null);
4079
4080                 final AdaptionService service = getSession().peekService(AdaptionService.class);
4081                 if (service == null)
4082                         procedure.exception(this, new ServiceException("No AdaptionService available"));
4083                 else
4084                         service.adapt(this, resource, resource, Resource.class, clazz, false, procedure);
4085
4086         }
4087
4088         @Override
4089         public <T> void forAdapted(Resource resource, Class<T> clazz,
4090                         SyncProcedure<T> procedure) {
4091                 forAdapted(resource, clazz, new SyncToAsyncProcedure<T>(procedure));
4092         }
4093
4094         @Override
4095         public <T> void forAdapted(Resource resource, Class<T> clazz,
4096                         Procedure<T> procedure) {
4097                 forAdapted(resource, clazz, new NoneToAsyncProcedure<T>(procedure));
4098         }
4099
4100         @Override
4101         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4102                         AsyncListener<T> listener) {
4103                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4104         }
4105
4106         @Override
4107         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4108                         SyncListener<T> listener) {
4109                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4110         }
4111
4112         @Override
4113         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4114                         Listener<T> listener) {
4115                 asyncRequest(new UniqueAdapter<T>(resource, clazz), listener);
4116         }
4117
4118         @Override
4119         final public <T> void forUniqueAdapted(final Resource resource,
4120                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
4121
4122                 assert (resource != null);
4123                 assert (clazz != null);
4124                 assert (procedure != null);
4125
4126                 final AdaptionService service = getSession().peekService(AdaptionService.class);
4127                 if (service == null)
4128                         procedure.exception(this, new ServiceException("No AdaptionService available"));
4129                 else
4130                         service.adaptNew(this, resource, clazz, false, procedure);
4131
4132         }
4133
4134         @Override
4135         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4136                         SyncProcedure<T> procedure) {
4137                 forUniqueAdapted(resource, clazz,
4138                                 new SyncToAsyncProcedure<T>(procedure));
4139         }
4140
4141         @Override
4142         public <T> void forUniqueAdapted(Resource resource, Class<T> clazz,
4143                         Procedure<T> procedure) {
4144                 forUniqueAdapted(resource, clazz,
4145                                 new NoneToAsyncProcedure<T>(procedure));
4146         }
4147
4148         @Override
4149         public void forPossibleInverse(Resource subject,
4150                         AsyncListener<Resource> listener) {
4151                 asyncRequest(new PossibleInverse(subject), listener);
4152         }
4153
4154         @Override
4155         public void forPossibleInverse(Resource subject,
4156                         SyncListener<Resource> listener) {
4157                 asyncRequest(new PossibleInverse(subject), listener);
4158         }
4159
4160         @Override
4161         public void forPossibleInverse(Resource subject, Listener<Resource> listener) {
4162                 asyncRequest(new PossibleInverse(subject), listener);
4163         }
4164
4165         @Override
4166         final public void forPossibleInverse(final Resource relation,
4167                         final AsyncProcedure<Resource> procedure) {
4168
4169                 assert (relation != null);
4170                 assert (procedure != null);
4171
4172                 processor.forInverse(this, relation, new ExceptionToNullProcedure<Resource>(procedure));
4173
4174         }
4175
4176         @Override
4177         public void forPossibleInverse(Resource subject,
4178                         SyncProcedure<Resource> procedure) {
4179                 forPossibleInverse(subject, new SyncToAsyncProcedure<Resource>(
4180                                 procedure));
4181         }
4182
4183         @Override
4184         public void forPossibleInverse(Resource subject,
4185                         Procedure<Resource> procedure) {
4186                 forPossibleInverse(subject, new NoneToAsyncProcedure<Resource>(
4187                                 procedure));
4188         }
4189
4190         @Override
4191         public void forPossibleObject(Resource subject, Resource relation,
4192                         AsyncListener<Resource> listener) {
4193                 asyncRequest(new PossibleObject(subject, relation), listener);
4194         }
4195
4196         @Override
4197         public void forPossibleObject(Resource subject, Resource relation,
4198                         SyncListener<Resource> listener) {
4199                 asyncRequest(new PossibleObject(subject, relation), listener);
4200         }
4201
4202         @Override
4203         public void forPossibleObject(Resource subject, Resource relation,
4204                         Listener<Resource> listener) {
4205                 asyncRequest(new PossibleObject(subject, relation), listener);
4206         }
4207
4208         @Override
4209         final public void forPossibleObject(final Resource subject,
4210                         final Resource relation, final AsyncProcedure<Resource> procedure) {
4211
4212                 assert (subject != null);
4213                 assert (relation != null);
4214                 assert (procedure != null);
4215
4216                 processor.forEachObject(this, subject, relation,
4217                                 new SingleOrNullProcedure<Resource>(procedure));
4218
4219         }
4220
4221         @Override
4222         public void forPossibleObject(Resource subject, Resource relation,
4223                         SyncProcedure<Resource> procedure) {
4224                 forPossibleObject(subject, relation,
4225                                 new SyncToAsyncProcedure<Resource>(procedure));
4226         }
4227
4228         @Override
4229         public void forPossibleObject(Resource subject, Resource relation,
4230                         Procedure<Resource> procedure) {
4231                 forPossibleObject(subject, relation,
4232                                 new NoneToAsyncProcedure<Resource>(procedure));
4233         }
4234
4235         @Override
4236         public void forPossibleStatement(Resource subject, Resource relation,
4237                         AsyncListener<Statement> listener) {
4238                 asyncRequest(new PossibleStatement(subject, relation), listener);
4239         }
4240
4241         @Override
4242         public void forPossibleStatement(Resource subject, Resource relation,
4243                         SyncListener<Statement> listener) {
4244                 asyncRequest(new PossibleStatement(subject, relation), listener);
4245         }
4246
4247         @Override
4248         public void forPossibleStatement(Resource subject, Resource relation,
4249                         Listener<Statement> listener) {
4250                 asyncRequest(new PossibleStatement(subject, relation), listener);
4251         }
4252
4253         @Override
4254         final public void forPossibleStatement(final Resource subject,
4255                         final Resource relation, final AsyncProcedure<Statement> procedure) {
4256
4257                 assert (subject != null);
4258                 assert (relation != null);
4259                 assert (procedure != null);
4260
4261                 processor.forEachStatement(this, subject, relation,
4262                                 new SingleFunctionalOrNullProcedure<Statement>(
4263                                                 "forPossibleStatement", procedure));
4264
4265         }
4266
4267         @Override
4268         public void forPossibleStatement(Resource subject, Resource relation,
4269                         SyncProcedure<Statement> procedure) {
4270                 forPossibleStatement(subject, relation,
4271                                 new SyncToAsyncProcedure<Statement>(procedure));
4272         }
4273
4274         @Override
4275         public void forPossibleStatement(Resource subject, Resource relation,
4276                         Procedure<Statement> procedure) {
4277                 forPossibleStatement(subject, relation,
4278                                 new NoneToAsyncProcedure<Statement>(procedure));
4279         }
4280
4281         @Override
4282         public void forPossibleType(Resource subject, Resource relation,
4283                         AsyncListener<Resource> listener) {
4284                 asyncRequest(new PossibleType(subject, relation), listener);
4285         }
4286
4287         @Override
4288         public void forPossibleType(Resource subject, Resource relation,
4289                         SyncListener<Resource> listener) {
4290                 asyncRequest(new PossibleType(subject, relation), listener);
4291         }
4292
4293         @Override
4294         public void forPossibleType(Resource subject, Resource relation,
4295                         Listener<Resource> listener) {
4296                 asyncRequest(new PossibleType(subject, relation), listener);
4297         }
4298
4299         @Override
4300         final public void forPossibleType(final Resource subject,
4301                         final Resource baseType, final AsyncProcedure<Resource> procedure) {
4302
4303                 assert (subject != null);
4304                 assert (procedure != null);
4305
4306                 final NullSingleOrNullProcedure<Resource> checkedProcedure = new NullSingleOrNullProcedure<Resource>(procedure);
4307
4308                 processor.forEachPrincipalType(this, subject, new AsyncMultiProcedureAdapter<Resource>() {
4309
4310                                         @Override
4311                                         public void execute(AsyncReadGraph graph,
4312                                                         final Resource principalType) {
4313
4314                                                 if (baseType == null) {
4315
4316                                                         checkedProcedure.offer(graph, principalType);
4317
4318                                                 } else if (principalType.equals(baseType)) {
4319
4320                                                         checkedProcedure.offer(graph, principalType);
4321
4322                                                 } else {
4323
4324                                                         checkedProcedure.inc();
4325
4326                                                         processor.forSupertypes((ReadGraphImpl)graph, principalType,
4327                                                                         new AsyncProcedure<Set<Resource>>() {
4328
4329                                                                                 @Override
4330                                                                                 public void execute(
4331                                                                                                 AsyncReadGraph graph,
4332                                                                                                 Set<Resource> result) {
4333
4334                                                                                         if (result.contains(baseType)) {
4335                                                                                                 checkedProcedure.offer(graph,
4336                                                                                                                 principalType);
4337                                                                                         }
4338
4339                                                                                         checkedProcedure.dec(graph);
4340
4341                                                                                 }
4342
4343                                                                                 @Override
4344                                                                                 public void exception(
4345                                                                                                 AsyncReadGraph graph,
4346                                                                                                 Throwable t) {
4347                                                                                         checkedProcedure.exception(graph, t);
4348                                                                                         checkedProcedure.dec(graph);
4349                                                                                 }
4350
4351                                                                                 @Override
4352                                                                                 public String toString() {
4353                                                                                         return "forPossibleType -> "
4354                                                                                                         + procedure;
4355                                                                                 }
4356
4357                                                                         });
4358
4359                                                 }
4360
4361                                         }
4362
4363                                         @Override
4364                                         public void finished(AsyncReadGraph graph) {
4365                                                 checkedProcedure.dec(graph);
4366                                         }
4367
4368                                         @Override
4369                                         public void exception(AsyncReadGraph graph, Throwable t) {
4370                                                 checkedProcedure.exception(graph, t);
4371                                                 checkedProcedure.dec(graph);
4372                                         }
4373
4374                                 });
4375
4376         }
4377
4378         @Override
4379         public void forPossibleType(Resource subject, Resource relation,
4380                         SyncProcedure<Resource> procedure) {
4381                 forPossibleType(subject, relation, new SyncToAsyncProcedure<Resource>(
4382                                 procedure));
4383         }
4384
4385         @Override
4386         public void forPossibleType(Resource subject, Resource relation,
4387                         Procedure<Resource> procedure) {
4388                 forPossibleType(subject, relation, new NoneToAsyncProcedure<Resource>(
4389                                 procedure));
4390         }
4391
4392         @Override
4393         public <T> void forPossibleValue(Resource subject, AsyncListener<T> listener) {
4394                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4395         }
4396
4397         @Override
4398         public <T> void forPossibleValue(Resource subject, SyncListener<T> listener) {
4399                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4400         }
4401
4402         @Override
4403         public <T> void forPossibleValue(Resource subject, Listener<T> listener) {
4404                 asyncRequest(new PossibleValueImplied<T>(subject), listener);
4405         }
4406
4407         @Override
4408         final public <T> void forPossibleValue(final Resource subject,
4409                         final AsyncProcedure<T> procedure) {
4410
4411                 assert (subject != null);
4412                 assert (procedure != null);
4413
4414                 forPossibleRelatedValue(subject, processor.getL0(this).HasDataType, DATA_TYPE_BINDING_INTERNAL, new AsyncProcedure<Datatype>() {
4415
4416                         @Override
4417                         public void execute(AsyncReadGraph graph, final Datatype type) {
4418                                 if (type == null) {
4419                                         procedure.execute(graph, null);
4420                                 } else {
4421                                         try {
4422                                                 // TODO: consider trying Bindings.getBeanBinding(type);
4423                                                 Binding binding = Bindings.getBinding(type);
4424                                                 graph.forPossibleValue(subject, binding, procedure);
4425                                         } catch (RuntimeBindingConstructionException e) {
4426                                                 procedure.exception(graph, e);
4427                                         }
4428                                 }
4429                         }
4430
4431                         @Override
4432                         public void exception(AsyncReadGraph graph, Throwable t) {
4433                                 procedure.exception(graph, t);
4434                         }
4435
4436                         @Override
4437                         public String toString() {
4438                                 return "forPossibleValue -> " + procedure;
4439                         }
4440
4441                 });
4442
4443         }
4444
4445         @Override
4446         public <T> void forPossibleValue(Resource subject,
4447                         SyncProcedure<T> procedure) {
4448                 forPossibleValue(subject, new SyncToAsyncProcedure<T>(procedure));
4449         }
4450
4451         @Override
4452         public <T> void forPossibleValue(Resource subject, Procedure<T> procedure) {
4453                 forPossibleValue(subject, new NoneToAsyncProcedure<T>(procedure));
4454         }
4455
4456         @Override
4457         public <T> void forPossibleValue(Resource subject, Binding binding,
4458                         AsyncListener<T> listener) {
4459                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4460         }
4461
4462         @Override
4463         public <T> void forPossibleValue(Resource subject, Binding binding,
4464                         SyncListener<T> listener) {
4465                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4466         }
4467
4468         @Override
4469         public <T> void forPossibleValue(Resource subject, Binding binding,
4470                         Listener<T> listener) {
4471                 asyncRequest(new PossibleValue<T>(subject, binding), listener);
4472         }
4473
4474         @Override
4475         final public <T> void forPossibleValue(final Resource resource,
4476                         final Binding binding, final AsyncProcedure<T> procedure) {
4477
4478                 assert (resource != null);
4479                 assert (binding != null);
4480                 assert (procedure != null);
4481
4482                 processor.forValue(this, resource, new AsyncProcedure<byte[]>() {
4483
4484                         @Override
4485                         public void execute(AsyncReadGraph graph, byte[] result) {
4486
4487                                 try {
4488
4489                                         if (result == null) {
4490                                                 procedure.execute(graph, null);
4491                                                 return;
4492                                         }
4493
4494                                         Serializer serializer = Bindings.getSerializer( binding );
4495                                         Object obj = serializer.deserialize(result);
4496                                         if (!binding.isInstance(obj))
4497                                                 procedure.exception(graph, new ClassCastException(
4498                                                                 "Cannot get value " + obj + " with binding "
4499                                                                                 + binding));
4500                                         else
4501                                                 procedure.execute(graph, (T) obj);
4502
4503                                 } catch (IOException e) {
4504                                         procedure.exception(graph, e);
4505                                 } catch (BufferUnderflowException e) {
4506                                         procedure.exception(graph, e);
4507                                 } catch (Throwable t) {
4508                                         procedure.exception(graph, t);
4509                                 }
4510
4511                         }
4512
4513                         @Override
4514                         public void exception(AsyncReadGraph graph, Throwable t) {
4515                                 try {
4516                                         procedure.exception(graph, t);
4517                                 } catch (Throwable t2) {
4518                                 Logger.defaultLogError(t2);
4519                                 }
4520                         }
4521
4522                         @Override
4523                         public String toString() {
4524                                 return "forPossibleValue -> " + procedure;
4525                         }
4526
4527                 });
4528
4529         }
4530
4531         @Override
4532         public <T> void forPossibleValue(Resource subject, Binding binding,
4533                         SyncProcedure<T> procedure) {
4534                 forPossibleValue(subject, binding, new SyncToAsyncProcedure<T>(
4535                                 procedure));
4536         }
4537
4538         @Override
4539         public <T> void forPossibleValue(Resource subject, Binding binding,
4540                         Procedure<T> procedure) {
4541                 forPossibleValue(subject, binding, new NoneToAsyncProcedure<T>(
4542                                 procedure));
4543         }
4544
4545         @Override
4546         public <T> void forPossibleRelatedValue(Resource subject,
4547                         Resource relation, AsyncListener<T> listener) {
4548                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4549                                 listener);
4550         }
4551
4552         @Override
4553         public <T> void forPossibleRelatedValue(Resource subject,
4554                         Resource relation, SyncListener<T> listener) {
4555                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4556                                 listener);
4557         }
4558
4559         @Override
4560         public <T> void forPossibleRelatedValue(Resource subject,
4561                         Resource relation, Listener<T> listener) {
4562                 asyncRequest(new PossibleRelatedValueImplied<T>(subject, relation),
4563                                 listener);
4564         }
4565
4566         @Override
4567         final public <T> void forPossibleRelatedValue(final Resource subject,
4568                         final Resource relation, final AsyncProcedure<T> procedure) {
4569
4570                 assert (subject != null);
4571                 assert (relation != null);
4572                 assert (procedure != null);
4573
4574                 final DeepSingleOrNullProcedure<T> checkedProcedure = new DeepSingleOrNullProcedure<T>(procedure);
4575
4576                 processor.forEachObject(this, subject, relation,
4577                                 new AsyncMultiProcedureAdapter<Resource>() {
4578
4579                                         @Override
4580                                         public void execute(AsyncReadGraph graph,
4581                                                         final Resource object) {
4582
4583                                                 checkedProcedure.inc();
4584
4585                                                 graph.forValue(object, new AsyncProcedure<Object>() {
4586
4587                                                         @Override
4588                                                         public void execute(AsyncReadGraph graph,
4589                                                                         Object result) {
4590                                                                 checkedProcedure.offer(graph, (T) result);
4591                                                                 checkedProcedure.dec(graph);
4592                                                         }
4593
4594                                                         @Override
4595                                                         public void exception(AsyncReadGraph graph,
4596                                                                         Throwable t) {
4597                                                                 checkedProcedure.exception(graph, t);
4598                                                                 checkedProcedure.dec(graph);
4599                                                         }
4600
4601                                                 });
4602
4603                                         }
4604
4605                                         @Override
4606                                         public void finished(AsyncReadGraph graph) {
4607
4608                                                 checkedProcedure.dec(graph);
4609                                         }
4610
4611                                         @Override
4612                                         public void exception(AsyncReadGraph graph, Throwable t) {
4613                                                 checkedProcedure.exception(graph, t);
4614                                                 checkedProcedure.dec(graph);
4615                                         }
4616
4617                                         @Override
4618                                         public String toString() {
4619                                                 return "forPossibleRelatedValue -> " + procedure;
4620                                         }
4621                                 });
4622
4623         }
4624
4625         @Override
4626         public <T> void forPossibleRelatedValue(Resource subject,
4627                         Resource relation, SyncProcedure<T> procedure) {
4628                 forPossibleRelatedValue(subject, relation, new SyncToAsyncProcedure<T>(
4629                                 procedure));
4630         }
4631
4632         @Override
4633         public <T> void forPossibleRelatedValue(Resource subject,
4634                         Resource relation, Procedure<T> procedure) {
4635                 forPossibleRelatedValue(subject, relation, new NoneToAsyncProcedure<T>(
4636                                 procedure));
4637         }
4638
4639         @Override
4640         public <T> void forPossibleRelatedValue(Resource subject,
4641                         Resource relation, Binding binding, AsyncListener<T> listener) {
4642                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4643                                 listener);
4644         }
4645
4646         @Override
4647         public <T> void forPossibleRelatedValue(Resource subject,
4648                         Resource relation, Binding binding, SyncListener<T> listener) {
4649                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4650                                 listener);
4651         }
4652
4653         @Override
4654         public <T> void forPossibleRelatedValue(Resource subject,
4655                         Resource relation, Binding binding, Listener<T> listener) {
4656                 asyncRequest(new PossibleRelatedValue<T>(subject, relation, binding),
4657                                 listener);
4658         }
4659
4660 //      @Override
4661 //      final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4662 //                      final AsyncProcedure<T> procedure) {
4663 //
4664 //              forPossibleRelatedValue(subject, relation, binding, procedure, false);
4665 //
4666 //      }
4667
4668         final public <T> void forPossibleRelatedValue(final Resource subject, final Resource relation, final Binding binding,
4669                         final AsyncProcedure<T> procedure) {
4670
4671                 assert (subject != null);
4672                 assert (relation != null);
4673                 assert (procedure != null);
4674
4675                 processor.forPossibleObject(this, subject, relation, new AsyncProcedure<Resource>() {
4676
4677                         @Override
4678                         public void execute(AsyncReadGraph graph, Resource object) {
4679
4680                                 if(object == null) {
4681                                         procedure.execute(graph, null);
4682                                         return;
4683                                 }
4684
4685                                 processor.forPossibleValue((ReadGraphImpl)graph, object, new AsyncProcedure<byte[]>() {
4686
4687                                         @Override
4688                                         public void execute(AsyncReadGraph graph, byte[] bytes) {
4689
4690                                                 if(bytes != null) {
4691
4692                                                         try {
4693
4694                                                                 Serializer serializer = binding.serializer();
4695                                                                 Object obj = serializer.deserialize(bytes);
4696                                                                 if (!binding.isInstance(obj)) {
4697                                                                         procedure.exception(graph, new ClassCastException("Cannot get value " + obj + " with binding " + binding));
4698                                                                 } else {
4699                                                                         procedure.execute(graph, (T) obj);
4700                                                                 }
4701
4702                                                         } catch (Throwable t) {
4703
4704                                                                 procedure.exception(graph, t);
4705
4706                                                         }
4707
4708                                                 } else {
4709
4710                                                         procedure.execute(graph, null);
4711
4712                                                 }
4713
4714                                         }
4715
4716                                         @Override
4717                                         public void exception(AsyncReadGraph graph, Throwable t) {
4718                                                 procedure.exception(graph, t);
4719                                         }
4720
4721                                 });
4722
4723                         }
4724
4725                         @Override
4726                         public void exception(AsyncReadGraph graph, Throwable throwable) {
4727                                 throwable.printStackTrace();
4728                                 procedure.exception(graph, throwable);
4729                         }
4730
4731                 });
4732
4733         }
4734
4735         @Override
4736         public <T> void forPossibleRelatedValue(Resource subject,
4737                         Resource relation, Binding binding, SyncProcedure<T> procedure) {
4738                 forPossibleRelatedValue(subject, relation, binding,
4739                                 new SyncToAsyncProcedure<T>(procedure));
4740         }
4741
4742         @Override
4743         public <T> void forPossibleRelatedValue(Resource subject,
4744                         Resource relation, Binding binding, Procedure<T> procedure) {
4745                 forPossibleRelatedValue(subject, relation, binding,
4746                                 new NoneToAsyncProcedure<T>(procedure));
4747         }
4748
4749         @Override
4750         public void forIsInstanceOf(Resource subject, Resource relation,
4751                         AsyncListener<Boolean> listener) {
4752                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4753         }
4754
4755         @Override
4756         public void forIsInstanceOf(Resource subject, Resource relation,
4757                         SyncListener<Boolean> listener) {
4758                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4759         }
4760
4761         @Override
4762         public void forIsInstanceOf(Resource subject, Resource relation,
4763                         Listener<Boolean> listener) {
4764                 asyncRequest(new IsInstanceOf(subject, relation), listener);
4765         }
4766
4767         @Override
4768         final public void forIsInstanceOf(final Resource resource,
4769                         final Resource type, final AsyncProcedure<Boolean> procedure) {
4770
4771                 assert (resource != null);
4772                 assert (type != null);
4773                 assert (procedure != null);
4774
4775                 forTypes(resource, new AsyncProcedure<Set<Resource>>() {
4776
4777                         @Override
4778                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4779
4780                                 try {
4781                                         if (result.contains(type))
4782                                                 procedure.execute(graph, true);
4783                                         else
4784                                                 procedure.execute(graph, false);
4785                                 } catch (Throwable t) {
4786                                 Logger.defaultLogError(t);
4787                                 }
4788                         }
4789
4790                         @Override
4791                         public void exception(AsyncReadGraph graph, Throwable t) {
4792                                 try {
4793                                         procedure.exception(graph, t);
4794                                 } catch (Throwable t2) {
4795                                 Logger.defaultLogError(t2);
4796                                 }
4797                         }
4798
4799                         @Override
4800                         public String toString() {
4801                                 return "forIsInstanceOf -> " + procedure;
4802                         }
4803
4804                 });
4805
4806         }
4807
4808         @Override
4809         public void forIsInstanceOf(Resource subject, Resource relation,
4810                         SyncProcedure<Boolean> procedure) {
4811                 forIsInstanceOf(subject, relation, new SyncToAsyncProcedure<Boolean>(
4812                                 procedure));
4813         }
4814
4815         @Override
4816         public void forIsInstanceOf(Resource subject, Resource relation,
4817                         Procedure<Boolean> procedure) {
4818                 forIsInstanceOf(subject, relation, new NoneToAsyncProcedure<Boolean>(
4819                                 procedure));
4820         }
4821
4822         @Override
4823         public void forIsInheritedFrom(Resource subject, Resource relation,
4824                         AsyncListener<Boolean> listener) {
4825                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4826         }
4827
4828         @Override
4829         public void forIsInheritedFrom(Resource subject, Resource relation,
4830                         SyncListener<Boolean> listener) {
4831                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4832         }
4833
4834         @Override
4835         public void forIsInheritedFrom(Resource subject, Resource relation,
4836                         Listener<Boolean> listener) {
4837                 asyncRequest(new IsInheritedFrom(subject, relation), listener);
4838         }
4839
4840         @Override
4841         final public void forIsInheritedFrom(final Resource resource,
4842                         final Resource type, final AsyncProcedure<Boolean> procedure) {
4843
4844                 assert (resource != null);
4845                 assert (type != null);
4846                 assert (procedure != null);
4847
4848                 if (resource.equals(type)) {
4849                         try {
4850                                 procedure.execute(this, true);
4851                         } catch (Throwable t) {
4852                         Logger.defaultLogError(t);
4853                         }
4854                         return;
4855                 }
4856
4857                 forSupertypes(resource, new AsyncProcedure<Set<Resource>>() {
4858
4859                         @Override
4860                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4861                                 try {
4862                                         if (result.contains(type))
4863                                                 procedure.execute(graph, true);
4864                                         else
4865                                                 procedure.execute(graph, false);
4866                                 } catch (Throwable t) {
4867                                 Logger.defaultLogError(t);
4868                                 }
4869                         }
4870
4871                         @Override
4872                         public void exception(AsyncReadGraph graph, Throwable t) {
4873                                 try {
4874                                         procedure.exception(graph, t);
4875                                 } catch (Throwable t2) {
4876                                 Logger.defaultLogError(t2);
4877                                 }
4878                         }
4879
4880                         @Override
4881                         public String toString() {
4882                                 return "forIsInheritedFrom -> " + procedure;
4883                         }
4884
4885                 });
4886
4887         }
4888
4889         @Override
4890         public void forIsInheritedFrom(Resource subject, Resource relation,
4891                         SyncProcedure<Boolean> procedure) {
4892                 forIsInheritedFrom(subject, relation,
4893                                 new SyncToAsyncProcedure<Boolean>(procedure));
4894         }
4895
4896         @Override
4897         public void forIsInheritedFrom(Resource subject, Resource relation,
4898                         Procedure<Boolean> procedure) {
4899                 forIsInheritedFrom(subject, relation,
4900                                 new NoneToAsyncProcedure<Boolean>(procedure));
4901         }
4902
4903         @Override
4904         public void forIsSubrelationOf(Resource subject, Resource relation,
4905                         AsyncListener<Boolean> listener) {
4906                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4907         }
4908
4909         @Override
4910         public void forIsSubrelationOf(Resource subject, Resource relation,
4911                         SyncListener<Boolean> listener) {
4912                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4913         }
4914
4915         @Override
4916         public void forIsSubrelationOf(Resource subject, Resource relation,
4917                         Listener<Boolean> listener) {
4918                 asyncRequest(new IsSubrelationOf(subject, relation), listener);
4919         }
4920
4921         @Override
4922         final public void forIsSubrelationOf(final Resource resource,
4923                         final Resource relation, final AsyncProcedure<Boolean> procedure) {
4924
4925                 assert (resource != null);
4926                 assert (relation != null);
4927                 assert (procedure != null);
4928
4929                 if (resource.equals(relation)) {
4930                         procedure.execute(this, true);
4931                         return;
4932                 }
4933
4934                 forSuperrelations(resource, new AsyncProcedure<Set<Resource>>() {
4935
4936                         @Override
4937                         public void execute(AsyncReadGraph graph, Set<Resource> result) {
4938                                 try {
4939                                         if (result.contains(relation))
4940                                                 procedure.execute(graph, true);
4941                                         else
4942                                                 procedure.execute(graph, false);
4943                                 } catch (Throwable t) {
4944                                 Logger.defaultLogError(t);
4945                                 }
4946                         }
4947
4948                         @Override
4949                         public void exception(AsyncReadGraph graph, Throwable t) {
4950                                 try {
4951                                         procedure.exception(graph, t);
4952                                 } catch (Throwable t2) {
4953                                 Logger.defaultLogError(t2);
4954                                 }
4955                         }
4956
4957                         @Override
4958                         public String toString() {
4959                                 return "forIsSubrelationOf -> " + procedure;
4960                         }
4961
4962                 });
4963
4964         }
4965
4966         @Override
4967         public void forIsSubrelationOf(Resource subject, Resource relation,
4968                         SyncProcedure<Boolean> procedure) {
4969                 forIsSubrelationOf(subject, relation,
4970                                 new SyncToAsyncProcedure<Boolean>(procedure));
4971         }
4972
4973         @Override
4974         public void forIsSubrelationOf(Resource subject, Resource relation,
4975                         Procedure<Boolean> procedure) {
4976                 forIsSubrelationOf(subject, relation,
4977                                 new NoneToAsyncProcedure<Boolean>(procedure));
4978         }
4979
4980         @Override
4981         public void forHasStatement(Resource subject,
4982                         AsyncListener<Boolean> listener) {
4983                 asyncRequest(new HasStatementSubject(subject), listener);
4984         }
4985
4986         @Override
4987         public void forHasStatement(Resource subject, SyncListener<Boolean> listener) {
4988                 asyncRequest(new HasStatementSubject(subject), listener);
4989         }
4990
4991         @Override
4992         public void forHasStatement(Resource subject, Listener<Boolean> listener) {
4993                 asyncRequest(new HasStatementSubject(subject), listener);
4994         }
4995
4996         @Override
4997         final public void forHasStatement(final Resource subject,
4998                         final AsyncProcedure<Boolean> procedure) {
4999
5000                 assert (subject != null);
5001                 assert (procedure != null);
5002
5003                 processor.forHasStatement(this, subject, procedure);
5004
5005         }
5006
5007         @Override
5008         public void forHasStatement(Resource subject,
5009                         SyncProcedure<Boolean> procedure) {
5010                 forHasStatement(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5011         }
5012
5013         @Override
5014         public void forHasStatement(Resource subject, Procedure<Boolean> procedure) {
5015                 forHasStatement(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5016         }
5017
5018         @Override
5019         public void forHasStatement(Resource subject, Resource relation,
5020                         AsyncListener<Boolean> listener) {
5021                 asyncRequest(new HasStatement(subject, relation), listener);
5022         }
5023
5024         @Override
5025         public void forHasStatement(Resource subject, Resource relation,
5026                         SyncListener<Boolean> listener) {
5027                 asyncRequest(new HasStatement(subject, relation), listener);
5028         }
5029
5030         @Override
5031         public void forHasStatement(Resource subject, Resource relation,
5032                         Listener<Boolean> listener) {
5033                 asyncRequest(new HasStatement(subject, relation), listener);
5034         }
5035
5036         @Override
5037         final public void forHasStatement(final Resource subject,
5038                         final Resource relation, final AsyncProcedure<Boolean> procedure) {
5039
5040                 assert (subject != null);
5041                 assert (relation != null);
5042                 assert (procedure != null);
5043
5044                 processor.forHasStatement(this, subject, relation, procedure);
5045
5046         }
5047
5048         @Override
5049         public void forHasStatement(Resource subject, Resource relation,
5050                         SyncProcedure<Boolean> procedure) {
5051                 forHasStatement(subject, relation, new SyncToAsyncProcedure<Boolean>(
5052                                 procedure));
5053         }
5054
5055         @Override
5056         public void forHasStatement(Resource subject, Resource relation,
5057                         Procedure<Boolean> procedure) {
5058                 forHasStatement(subject, relation, new NoneToAsyncProcedure<Boolean>(
5059                                 procedure));
5060         }
5061
5062         @Override
5063         public void forHasStatement(Resource subject, Resource relation,
5064                         Resource object, AsyncListener<Boolean> listener) {
5065                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5066                                 listener);
5067         }
5068
5069         @Override
5070         public void forHasStatement(Resource subject, Resource relation,
5071                         Resource object, SyncListener<Boolean> listener) {
5072                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5073                                 listener);
5074         }
5075
5076         @Override
5077         public void forHasStatement(Resource subject, Resource relation,
5078                         Resource object, Listener<Boolean> listener) {
5079                 asyncRequest(new HasStatementSubjectObject(subject, relation, object),
5080                                 listener);
5081         }
5082
5083         @Override
5084         final public void forHasStatement(final Resource subject,
5085                         final Resource relation, final Resource object,
5086                         final AsyncProcedure<Boolean> procedure) {
5087
5088                 assert (subject != null);
5089                 assert (relation != null);
5090                 assert (object != null);
5091                 assert (procedure != null);
5092
5093                 processor.forHasStatement(this, subject, relation, object, procedure);
5094
5095         }
5096
5097         @Override
5098         public void forHasStatement(Resource subject, Resource relation,
5099                         Resource object, SyncProcedure<Boolean> procedure) {
5100                 forHasStatement(subject, relation, object,
5101                                 new SyncToAsyncProcedure<Boolean>(procedure));
5102         }
5103
5104         @Override
5105         public void forHasStatement(Resource subject, Resource relation,
5106                         Resource object, Procedure<Boolean> procedure) {
5107                 forHasStatement(subject, relation, object,
5108                                 new NoneToAsyncProcedure<Boolean>(procedure));
5109         }
5110
5111         @Override
5112         public void forHasValue(Resource subject, AsyncListener<Boolean> listener) {
5113                 asyncRequest(new HasValue(subject), listener);
5114         }
5115
5116         @Override
5117         public void forHasValue(Resource subject, SyncListener<Boolean> listener) {
5118                 asyncRequest(new HasValue(subject), listener);
5119         }
5120
5121         @Override
5122         public void forHasValue(Resource subject, Listener<Boolean> listener) {
5123                 asyncRequest(new HasValue(subject), listener);
5124         }
5125
5126         @Override
5127         final public void forHasValue(final Resource subject,
5128                         final AsyncProcedure<Boolean> procedure) {
5129
5130                 assert (subject != null);
5131                 assert (procedure != null);
5132
5133                 processor.forValue(this, subject, new AsyncProcedure<byte[]>() {
5134
5135                         @Override
5136                         public void execute(AsyncReadGraph graph, byte[] result) {
5137                                 try {
5138                                         if (result == null)
5139                                                 procedure.execute(graph, false);
5140                                         else
5141                                                 procedure.execute(graph, true);
5142                                 } catch (Throwable t) {
5143                                 Logger.defaultLogError(t);
5144                                 }
5145                         }
5146
5147                         @Override
5148                         public void exception(AsyncReadGraph graph, Throwable t) {
5149                                 try {
5150                                         procedure.exception(graph, t);
5151                                 } catch (Throwable t2) {
5152                                 Logger.defaultLogError(t2);
5153                                 }
5154                         }
5155
5156                         @Override
5157                         public String toString() {
5158                                 return "forHasValue -> " + procedure;
5159                         }
5160
5161                 });
5162
5163         }
5164
5165         @Override
5166         public void forHasValue(Resource subject, SyncProcedure<Boolean> procedure) {
5167                 forHasValue(subject, new SyncToAsyncProcedure<Boolean>(procedure));
5168         }
5169
5170         @Override
5171         public void forHasValue(Resource subject, Procedure<Boolean> procedure) {
5172                 forHasValue(subject, new NoneToAsyncProcedure<Boolean>(procedure));
5173         }
5174
5175         @Override
5176         public void forOrderedSet(Resource subject,
5177                         AsyncMultiListener<Resource> listener) {
5178                 asyncRequest(new OrderedSet(subject), listener);
5179         }
5180
5181         @Override
5182         public void forOrderedSet(Resource subject,
5183                         SyncMultiListener<Resource> listener) {
5184                 asyncRequest(new OrderedSet(subject), listener);
5185         }
5186
5187         @Override
5188         public void forOrderedSet(Resource subject, MultiListener<Resource> listener) {
5189                 asyncRequest(new OrderedSet(subject), listener);
5190         }
5191
5192         @Override
5193         final public void forOrderedSet(final Resource subject,
5194                         final AsyncMultiProcedure<Resource> procedure) {
5195
5196                 assert (subject != null);
5197                 assert (procedure != null);
5198
5199                 processor.forOrderedSet(this, subject,
5200                                 new AsyncMultiProcedure<Resource>() {
5201
5202                                         @Override
5203                                         public void finished(AsyncReadGraph graph) {
5204                                                 try {
5205                                                         procedure.finished(graph);
5206                                                 } catch (Throwable t) {
5207                                                 Logger.defaultLogError(t);
5208                                                 }
5209                                         }
5210
5211                                         @Override
5212                                         public void execute(AsyncReadGraph graph, Resource result) {
5213                                                 try {
5214                                                         procedure.execute(graph, result);
5215                                                 } catch (Throwable t) {
5216                                                 Logger.defaultLogError(t);
5217                                                 }
5218                                         }
5219
5220                                         @Override
5221                                         public void exception(AsyncReadGraph graph, Throwable t) {
5222                                                 try {
5223                                                         procedure.exception(graph, t);
5224                                                 } catch (Throwable t2) {
5225                                                 Logger.defaultLogError(t2);
5226                                                 }
5227                                         }
5228
5229                                         @Override
5230                                         public String toString() {
5231                                                 return "forOrderedSet -> " + procedure;
5232                                         }
5233
5234                                 });
5235
5236         }
5237
5238         @Override
5239         public void forOrderedSet(Resource subject,
5240                         SyncMultiProcedure<Resource> procedure) {
5241                 forOrderedSet(subject, new SyncToAsyncMultiProcedure<Resource>(
5242                                 procedure));
5243         }
5244
5245         @Override
5246         public void forOrderedSet(Resource subject,
5247                         MultiProcedure<Resource> procedure) {
5248                 forOrderedSet(subject, new NoneToAsyncMultiProcedure<Resource>(
5249                                 procedure));
5250         }
5251
5252         @Override
5253         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5254                         AsyncListener<T> listener) {
5255                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5256         }
5257
5258         @Override
5259         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5260                         SyncListener<T> listener) {
5261                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5262         }
5263
5264         @Override
5265         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5266                         Listener<T> listener) {
5267                 asyncRequest(new PossibleAdapter<T>(resource, clazz), listener);
5268         }
5269
5270         @Override
5271         final public <T> void forPossibleAdapted(final Resource resource,
5272                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
5273
5274                 assert (resource != null);
5275                 assert (clazz != null);
5276                 assert (procedure != null);
5277
5278                 final AdaptionService service = getSession().peekService(AdaptionService.class);
5279                 if (service == null)
5280                         procedure.exception(this, new ServiceException("No AdaptionService available"));
5281                 else
5282                         service.adapt(this, resource, resource, Resource.class, clazz, true, procedure);
5283         }
5284
5285         @Override
5286         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5287                         SyncProcedure<T> procedure) {
5288                 forPossibleAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5289                                 procedure));
5290         }
5291
5292         @Override
5293         public <T> void forPossibleAdapted(Resource resource, Class<T> clazz,
5294                         Procedure<T> procedure) {
5295                 forPossibleAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5296                                 procedure));
5297         }
5298
5299         @Override
5300         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5301                         AsyncListener<T> listener) {
5302                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5303         }
5304
5305         @Override
5306         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5307                         SyncListener<T> listener) {
5308                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5309         }
5310
5311         @Override
5312         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5313                         Listener<T> listener) {
5314                 asyncRequest(new PossibleUniqueAdapter<T>(resource, clazz), listener);
5315         }
5316
5317         @Override
5318         final public <T> void forPossibleUniqueAdapted(final Resource resource,
5319                         final Class<T> clazz, final AsyncProcedure<T> procedure) {
5320
5321                 assert (resource != null);
5322                 assert (clazz != null);
5323                 assert (procedure != null);
5324
5325                 final AdaptionService service = getSession().peekService(AdaptionService.class);
5326                 if (service == null)
5327                         procedure.exception(this, new ServiceException("No AdaptionService available"));
5328                 else
5329                         service.adaptNew(this, resource, clazz, true, procedure);
5330
5331         }
5332
5333         @Override
5334         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5335                         SyncProcedure<T> procedure) {
5336                 forPossibleUniqueAdapted(resource, clazz, new SyncToAsyncProcedure<T>(
5337                                 procedure));
5338         }
5339
5340         @Override
5341         public <T> void forPossibleUniqueAdapted(Resource resource, Class<T> clazz,
5342                         Procedure<T> procedure) {
5343                 forPossibleUniqueAdapted(resource, clazz, new NoneToAsyncProcedure<T>(
5344                                 procedure));
5345         }
5346
5347         /*
5348          * Implementation of the interface AsyncRequestProcessor
5349          */
5350
5351         @Override
5352         final public Session getSession() {
5353                 return processor.getSession();
5354         }
5355
5356 //      @Override
5357 //      final public Builtins getBuiltins() {
5358 //              return processor.getSession().getBuiltins();
5359 //      }
5360
5361         @Override
5362         public <T> void asyncRequest(final Read<T> request) {
5363
5364                 asyncRequest(request, new AsyncProcedure<T>() {
5365
5366                         @Override
5367                         public void execute(AsyncReadGraph graph, T result) {
5368                         }
5369
5370                         @Override
5371                         public void exception(AsyncReadGraph graph, Throwable t) {
5372                                 Logger.defaultLogError(t);
5373                         }
5374
5375                         @Override
5376                         public String toString() {
5377                                 return "asyncRequest(Read) -> " + request;
5378                         }
5379
5380                 });
5381
5382         }
5383
5384         @Override
5385         public <T> void asyncRequest(Read<T> request, AsyncListener<T> procedure) {
5386                 asyncRequest(request, (AsyncProcedure<T>) procedure);
5387         }
5388
5389         @Override
5390         public <T> void asyncRequest(Read<T> request,
5391                         final SyncListener<T> procedure) {
5392                 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5393         }
5394
5395         @Override
5396         public <T> void asyncRequest(Read<T> request, final Listener<T> procedure) {
5397                 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5398         }
5399
5400         @Override
5401         public <T> void asyncRequest(final Read<T> request, final AsyncProcedure<T> procedure) {
5402
5403                 assert (request != null);
5404                 assert (procedure != null);
5405
5406                 final ListenerBase listener = getListenerBase(procedure);
5407
5408                 if (parent != null || listener != null) {
5409
5410                         try {
5411                                 processor.query(this, request, parent, procedure,listener);
5412                         } catch (DatabaseException e) {
5413                                 Logger.defaultLogError(e);
5414                                 // This throwable has already been transferred to procedure at this point - do nothing about it
5415                                 //
5416                         }
5417
5418                 } else {
5419
5420 //                      final ReadGraphImpl newGraph = newSync();
5421
5422                         try {
5423
5424                                 T result = request.perform(this);
5425
5426                                 try {
5427                                         procedure.execute(this, result);
5428                                 } catch (Throwable t) {
5429                                         Logger.defaultLogError(t);
5430                                 }
5431
5432                         } catch (Throwable t) {
5433
5434                                 try {
5435                                         procedure.exception(this, t);
5436                                 } catch (Throwable t2) {
5437                                         Logger.defaultLogError(t2);
5438                                 }
5439
5440                         } finally {
5441
5442                         }
5443
5444                 }
5445
5446         }
5447
5448     public static ReadGraphImpl createAsync(QueryProcessor support) {
5449         return new ReadGraphImpl(null, support);
5450     }
5451
5452     public static ReadGraphImpl forRecompute(CacheEntry entry, QueryProcessor support) {
5453         return new ReadGraphImpl(entry, support);
5454     }
5455
5456         @Override
5457         public <T> void asyncRequest(Read<T> request, SyncProcedure<T> procedure) {
5458                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5459         }
5460
5461         @Override
5462         public <T> void asyncRequest(Read<T> request, final Procedure<T> procedure) {
5463                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5464         }
5465
5466         @Override
5467         final public <T> void asyncRequest(final AsyncRead<T> request) {
5468
5469                 assert (request != null);
5470
5471                 asyncRequest(request, new AsyncProcedure<T>() {
5472
5473                         @Override
5474                         public void execute(AsyncReadGraph graph, T result) {
5475                         }
5476
5477                         @Override
5478                         public void exception(AsyncReadGraph graph, Throwable t) {
5479                         Logger.defaultLogError(t);
5480                         }
5481
5482                         @Override
5483                         public String toString() {
5484                                 return "asyncRequest(AsyncRead) -> " + request;
5485                         }
5486
5487                 });
5488
5489         }
5490
5491         @Override
5492         public <T> void asyncRequest(AsyncRead<T> request,
5493                         AsyncListener<T> procedure) {
5494                 asyncRequest(request, (AsyncProcedure<T>) procedure);
5495         }
5496
5497         @Override
5498         final public <T> void asyncRequest(AsyncRead<T> request,
5499                         final SyncListener<T> procedure) {
5500                 asyncRequest(request, new SyncToAsyncListener<T>(procedure));
5501         }
5502
5503         @Override
5504         final public <T> void asyncRequest(AsyncRead<T> request,
5505                         final Listener<T> procedure) {
5506                 asyncRequest(request, new NoneToAsyncListener<T>(procedure));
5507         }
5508
5509         @Override
5510         final public <T> void asyncRequest(final AsyncRead<T> request,
5511                         final AsyncProcedure<T> procedure) {
5512
5513                 assert (request != null);
5514                 assert (procedure != null);
5515
5516                 final ListenerBase listener = getListenerBase(procedure);
5517
5518                 if (parent != null || listener != null) {
5519
5520                         try {
5521                                 processor.query(this, request, parent, procedure, listener);
5522                         } catch (DatabaseException e) {
5523                                 Logger.defaultLogError(e);
5524                         }
5525
5526                 } else {
5527
5528                         try {
5529
5530                                 request.perform(this, new CallWrappedSingleQueryProcedure4<T>(procedure, request));
5531
5532                         } catch (Throwable t) {
5533
5534                                 if (t instanceof DatabaseException)
5535                                         procedure.exception(this, t);
5536                                 else
5537                                         procedure
5538                                                         .exception(
5539                                                                         this,
5540                                                                         new DatabaseException(
5541                                                                                         "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5542                                                                                         t));
5543
5544                         }
5545
5546                 }
5547
5548         }
5549
5550         @Override
5551         public <T> void asyncRequest(AsyncRead<T> request,
5552                         SyncProcedure<T> procedure) {
5553                 asyncRequest(request, new SyncToAsyncProcedure<T>(procedure));
5554         }
5555
5556         @Override
5557         final public <T> void asyncRequest(final AsyncRead<T> request,
5558                         final Procedure<T> procedure) {
5559                 asyncRequest(request, new NoneToAsyncProcedure<T>(procedure));
5560         }
5561
5562         @Override
5563         public <T> void asyncRequest(final MultiRead<T> request) {
5564
5565                 assert (request != null);
5566
5567                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5568                         @Override
5569                         public void exception(AsyncReadGraph graph, Throwable t) {
5570                         Logger.defaultLogError(t);
5571                         }
5572
5573                         @Override
5574                         public String toString() {
5575                                 return "asyncRequest(MultiRead) -> " + request;
5576                         }
5577                 });
5578
5579         }
5580
5581         @Override
5582         public <T> void asyncRequest(MultiRead<T> request,
5583                         AsyncMultiListener<T> procedure) {
5584                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5585         }
5586
5587         @Override
5588         public <T> void asyncRequest(MultiRead<T> request,
5589                         SyncMultiListener<T> procedure) {
5590                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5591         }
5592
5593         @Override
5594         public <T> void asyncRequest(MultiRead<T> request,
5595                         MultiListener<T> procedure) {
5596                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5597         }
5598
5599         @Override
5600         public <T> void asyncRequest(final MultiRead<T> request,
5601                         final AsyncMultiProcedure<T> procedure) {
5602
5603                 assert (request != null);
5604                 assert (procedure != null);
5605
5606                 final ListenerBase listener = getListenerBase(procedure);
5607
5608                 if (parent != null || listener != null) {
5609
5610 //                  final ReadGraphImpl newGraph = newSync();
5611                     processor.query(this, request, parent, procedure,listener);
5612
5613                 } else {
5614
5615 //                  final ReadGraphImpl newGraph = newSync();
5616
5617                     try {
5618
5619                         request.perform(this, procedure);
5620
5621                     } catch (Throwable t) {
5622
5623                         procedure.exception(this, t);
5624
5625                     }
5626
5627                 }
5628
5629         }
5630
5631         @Override
5632         public <T> void asyncRequest(MultiRead<T> request,
5633                         SyncMultiProcedure<T> procedure) {
5634                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5635         }
5636
5637         @Override
5638         public <T> void asyncRequest(MultiRead<T> request,
5639                         MultiProcedure<T> procedure) {
5640                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5641         }
5642
5643         @Override
5644         final public <T> void asyncRequest(final AsyncMultiRead<T> request) {
5645
5646                 assert (request != null);
5647
5648                 asyncRequest(request, new AsyncMultiProcedureAdapter<T>() {
5649                         @Override
5650                         public void exception(AsyncReadGraph graph, Throwable t) {
5651                         Logger.defaultLogError(t);
5652                         }
5653
5654                         @Override
5655                         public String toString() {
5656                                 return "asyncRequest(AsyncMultiRead) -> " + request;
5657                         }
5658                 });
5659
5660         }
5661
5662         @Override
5663         public <T> void asyncRequest(AsyncMultiRead<T> request,
5664                         AsyncMultiListener<T> procedure) {
5665                 asyncRequest(request, (AsyncMultiProcedure<T>) procedure);
5666         }
5667
5668         @Override
5669         public <T> void asyncRequest(AsyncMultiRead<T> request,
5670                         SyncMultiListener<T> procedure) {
5671                 asyncRequest(request, new SyncToAsyncMultiListener<T>(procedure));
5672         }
5673
5674         @Override
5675         public <T> void asyncRequest(AsyncMultiRead<T> request,
5676                         MultiListener<T> procedure) {
5677                 asyncRequest(request, new NoneToAsyncMultiListener<T>(procedure));
5678         }
5679
5680         @Override
5681         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5682                         final AsyncMultiProcedure<T> procedure) {
5683
5684                 assert (request != null);
5685                 assert (procedure != null);
5686
5687                 ListenerBase listener = getListenerBase(procedure);
5688
5689                 if (parent != null || listener != null) {
5690
5691                         processor.query(this, request, parent, procedure, listener);
5692
5693                 } else {
5694
5695                         try {
5696
5697                                 request.perform(this, new AsyncMultiProcedure<T>() {
5698
5699                                         @Override
5700                                         public void execute(AsyncReadGraph graph, T result) {
5701                                                 procedure.execute(graph, result);
5702                                         }
5703
5704                                         @Override
5705                                         public void finished(AsyncReadGraph graph) {
5706                                                 procedure.finished(graph);
5707                                         }
5708
5709                                         @Override
5710                                         public void exception(AsyncReadGraph graph, Throwable t) {
5711                                                 procedure.exception(graph, t);
5712                                         }
5713
5714                                         @Override
5715                                         public String toString() {
5716                                                 return "asyncRequest(AsyncMultiRead) -> " + procedure;
5717                                         }
5718
5719                                 });
5720
5721                         } catch (Throwable t) {
5722
5723                                 procedure.exception(this, new DatabaseException(t));
5724
5725                         }
5726                 }
5727
5728         }
5729
5730         @Override
5731         public <T> void asyncRequest(AsyncMultiRead<T> request,
5732                         SyncMultiProcedure<T> procedure) {
5733                 asyncRequest(request, new SyncToAsyncMultiProcedure<T>(procedure));
5734         }
5735
5736         @Override
5737         final public <T> void asyncRequest(AsyncMultiRead<T> request,
5738                         final MultiProcedure<T> procedure) {
5739                 asyncRequest(request, new NoneToAsyncMultiProcedure<T>(procedure));
5740         }
5741
5742         @Override
5743         final public <T> void asyncRequest(final ExternalRead<T> request) {
5744
5745                 assert (request != null);
5746
5747                 asyncRequest(request, new Procedure<T>() {
5748
5749                         @Override
5750                         public void execute(T result) {
5751                         }
5752
5753                         @Override
5754                         public void exception(Throwable t) {
5755                         Logger.defaultLogError(t);
5756                         }
5757
5758                         @Override
5759                         public String toString() {
5760                                 return "asyncRequest(PrimitiveRead) -> " + request;
5761                         }
5762
5763                 });
5764
5765         }
5766
5767         @Override
5768         public <T> void asyncRequest(ExternalRead<T> request,
5769                         final Listener<T> procedure) {
5770                 asyncRequest(request, (Procedure<T>) procedure);
5771         }
5772
5773         @Override
5774         final public <T> void asyncRequest(final ExternalRead<T> request,
5775                         final Procedure<T> procedure) {
5776
5777                 assert (request != null);
5778                 assert (procedure != null);
5779
5780                 ListenerBase listener = getListenerBase(procedure);
5781
5782                 if (parent != null || listener != null) {
5783
5784                         processor.query(this, request, parent, procedure, listener);
5785
5786                 } else {
5787
5788                         try {
5789
5790                                 request.register(this, new Listener<T>() {
5791
5792                                         @Override
5793                                         public void execute(T result) {
5794                                                 procedure.execute(result);
5795                                         }
5796
5797                                         @Override
5798                                         public void exception(Throwable t) {
5799                                                 procedure.exception(t);
5800                                         }
5801
5802                                         @Override
5803                                         public String toString() {
5804                                                 return "asyncRequest(PrimitiveRead) -> " + request;
5805                                         }
5806
5807                                         @Override
5808                                         public boolean isDisposed() {
5809                                                 return true;
5810                                         }
5811
5812                                 });
5813
5814                         } catch (Throwable t) {
5815
5816                                 if (t instanceof DatabaseException)
5817                                         procedure.exception(t);
5818                                 else
5819                                         procedure
5820                                                         .exception(new DatabaseException(
5821                                                                         "Unexpected exception in ReadGraph.asyncRequest(SingleAsyncRead, SingleProcedure)",
5822                                                                         t));
5823
5824                         }
5825
5826                 }
5827
5828         }
5829
5830         @Override
5831         public void asyncRequest(final Write request) {
5832
5833                 assert (request != null);
5834
5835                 getSession().asyncRequest(request);
5836
5837 //              processor.asyncWrite(request);
5838
5839         }
5840
5841         @Override
5842         public <T> void asyncRequest(final WriteResult<T> request, Procedure<T> procedure) {
5843                 throw new Error("Not implemented.");
5844         }
5845
5846         @Override
5847         public void asyncRequest(Write request, Consumer<DatabaseException> callback) {
5848
5849                 assert (request != null);
5850
5851                 getSession().asyncRequest(request, callback);
5852
5853         }
5854
5855         @Override
5856         public void asyncRequest(final DelayedWrite request) {
5857
5858                 assert (request != null);
5859
5860                 getSession().asyncRequest(request);
5861
5862         }
5863
5864         @Override
5865         public <T> void asyncRequest(final DelayedWriteResult<T> request, Procedure<T> procedure) {
5866                 throw new Error("Not implemented.");
5867         }
5868
5869         @Override
5870         public void asyncRequest(DelayedWrite r,
5871                         Consumer<DatabaseException> callback) {
5872                 throw new Error("Not implemented.");
5873         }
5874
5875         @Override
5876         public void asyncRequest(final WriteOnly request) {
5877
5878                 assert (request != null);
5879
5880                 getSession().asyncRequest(request);
5881
5882         }
5883
5884         @Override
5885         public <T> void asyncRequest(final WriteOnlyResult<T> request, Procedure<T> procedure) {
5886                 throw new Error("Not implemented.");
5887         }
5888
5889         @Override
5890         public void asyncRequest(WriteOnly r, Consumer<DatabaseException> callback) {
5891                 throw new Error("Not implemented.");
5892         }
5893
5894         /*
5895          * Implementation of the interface ServiceLocator
5896          */
5897
5898         @Override
5899         public <T> T getService(Class<T> api) {
5900             if(WriteSupport.class == api) {
5901                 if(this instanceof WriteGraphImpl) {
5902                     WriteGraphImpl impl = (WriteGraphImpl)this;
5903                     return (T)impl.writeSupport;
5904                 }
5905             }
5906                 return getSession().getService(api);
5907         }
5908
5909         @Override
5910         public <T> T peekService(Class<T> api) {
5911                 return getSession().peekService(api);
5912         }
5913
5914         @Override
5915         public boolean hasService(Class<?> api) {
5916                 return getSession().hasService(api);
5917         }
5918
5919         @Override
5920         public <T> void registerService(Class<T> api, T service) {
5921                 getSession().registerService(api, service);
5922         }
5923
5924         @Override
5925         public boolean isImmutable(Resource resource) throws DatabaseException {
5926                 ResourceImpl impl = (ResourceImpl)resource;
5927                 return processor.isImmutable(impl.id);
5928         }
5929
5930         /*
5931          * Internal routines
5932          */
5933
5934         protected static String INTERNAL_ERROR_STRING = "Transaction aborted due to internal client error. Contact application support.";
5935
5936         /*
5937          * callerThread is the currently running thread state.syncThread is blocking for
5938          * this execution state.syncParent is the blocking request
5939          */
5940
5941         final private boolean isExternal(int thread) {
5942                 return thread == Integer.MIN_VALUE;
5943         }
5944
5945 //      final private boolean isSync(int thread) {
5946 //              return thread < -1 && thread > Integer.MIN_VALUE;
5947 //      }
5948
5949         ReadGraphImpl(ReadGraphImpl graph) {
5950                 this(graph.parent, graph.processor);
5951         }
5952
5953         ReadGraphImpl(CacheEntry parent, QueryProcessor support) {
5954 //              this.state = new ReadGraphState(barrier, support);
5955                 this.parent = parent;
5956                 this.processor = support;
5957         }
5958
5959         ReadGraphImpl(final QueryProcessor support) {
5960
5961 //              this.state = state;
5962                 this.processor = support;
5963                 this.parent = null;
5964
5965         }
5966
5967 //      public static ReadGraphImpl createSync(int syncThread, Object syncParent,
5968 //                      ReadGraphSupportImpl support) {
5969 //              return new ReadGraphImpl(syncThread, syncThread, syncParent, null,
5970 //                              support, new AsyncBarrierImpl(null));
5971 //      }
5972
5973         public static ReadGraphImpl create(QueryProcessor support) {
5974                 return new ReadGraphImpl(support);
5975         }
5976
5977 //      public ReadGraphImpl newAsync() {
5978 //              return this;
5979 ////            if(!state.synchronizedExecution) {
5980 ////                    return this;
5981 ////            } else {
5982 ////                    return new ReadGraphImpl(false, parent, state.support, state.barrier);
5983 ////            }
5984 //      }
5985
5986 //      public ReadGraphImpl newSync() {
5987 //              return new ReadGraphImpl(parent, processor);
5988 //      }
5989
5990         public ReadGraphImpl newSync(CacheEntry parentEntry) {
5991                 return new ReadGraphImpl(parentEntry, processor);
5992         }
5993
5994         public ReadGraphImpl newRestart(ReadGraphImpl impl) {
5995
5996                 WriteGraphImpl write = processor.getSession().getService(
5997                                 WriteGraphImpl.class);
5998
5999 //              if (write.callerThread != impl.callerThread)
6000 //                      return new WriteGraphImpl(impl.callerThread, parent, state.support, write.writeSupport, write.provider, write.state.barrier);
6001                 return write;
6002
6003         }
6004
6005 //      public ReadGraphImpl newSync(Object parentRequest) {
6006 //              return new ReadGraphImpl(callerThread, state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6007 //      }
6008
6009 //      public ReadGraphImpl newSync(final int callerThread, Object parentRequest) {
6010 //              assert (state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE && callerThread != Integer.MIN_VALUE));
6011 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6012 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6013 //      }
6014 //
6015 //      public ReadGraphImpl newSyncAsync(Object parentRequest) {
6016 ////            assert (callerThread < 0);
6017 //              return new ReadGraphImpl(callerThread, state.syncThread, parentRequest,
6018 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6019 //      }
6020 //
6021 //      public ReadGraphImpl newSyncAsync(final int callerThread,
6022 //                      Object parentRequest) {
6023 ////            assert (callerThread < 0);
6024 //              // assert(state.syncThread == callerThread || (state.syncThread == Integer.MIN_VALUE
6025 //              // && callerThread != Integer.MIN_VALUE) );
6026 //              return new ReadGraphImpl(callerThread, callerThread, parentRequest,
6027 //                              state.parent, state.support, new AsyncBarrierImpl(state.barrier));
6028 //      }
6029
6030         public ReadGraphImpl withAsyncParent(CacheEntry parent) {
6031                 return new ReadGraphImpl(parent, processor);
6032         }
6033
6034         public ReadGraphImpl withParent(CacheEntry parent) {
6035                 if(parent == this.parent) return this;
6036                 else return new ReadGraphImpl(parent, processor);
6037         }
6038
6039         final private ListenerBase getListenerBase(final Object procedure) {
6040                 if (procedure instanceof ListenerBase)
6041                         return (ListenerBase) procedure;
6042                 else
6043                         return null;
6044         }
6045
6046         public <T> void waitAsyncProcedure(AsyncMultiReadProcedure<T> procedure) {
6047
6048                 assert(procedure.done());
6049
6050 //              while (!procedure.done()) {
6051 //
6052 //                      boolean executed = processor.resumeTasks(callerThread, null, null);
6053 //                      if (!executed) {
6054 //                              try {
6055 //                                      Thread.sleep(1);
6056 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6057 //                              } catch (InterruptedException e) {
6058 //                                      e.printStackTrace();
6059 //                              }
6060 //                      }
6061 //
6062 //              }
6063
6064         }
6065
6066         public <T> void waitAsyncProcedure(AsyncReadProcedure<T> procedure) {
6067
6068                 assert(procedure.done());
6069
6070 //              while (!procedure.done()) {
6071 //
6072 //                      boolean executed = processor.processor.resume(this);
6073 //                      if (!executed) {
6074 //                              try {
6075 //                                      Thread.sleep(1);
6076 //                                      //                                                              sema.tryAcquire(1, TimeUnit.MILLISECONDS);
6077 //                              } catch (InterruptedException e) {
6078 //                                      e.printStackTrace();
6079 //                              }
6080 //                      }
6081 //
6082 //              }
6083
6084         }
6085
6086 //      public void waitAsync(Object request) {
6087 //              try {
6088 //                      state.barrier.waitBarrier(request, this);
6089 //              } catch (Throwable t) {
6090 //                      t.printStackTrace();
6091 //                      processor.scanPending();
6092 //                      processor.querySupport.checkTasks();
6093 //                      throw new RuntimeDatabaseException(t);
6094 //              }
6095 //      }
6096
6097 //      public void restart() {
6098 //              state.barrier.restart();
6099 //      }
6100
6101         public boolean resumeTasks() {
6102                 return processor.resumeTasks(this);
6103         }
6104
6105         Class<?> singleClass(Set<Resource> types) {
6106                 Class<?> result = null;
6107                 for (Resource type : types) {
6108                         Class<?> clazz = processor.getBuiltinValue(type);
6109                         if (clazz != null) {
6110                                 if (result != null)
6111                                         return null;
6112                                 else
6113                                         result = clazz;
6114                         }
6115                 }
6116                 return result;
6117         }
6118
6119         private String debugString(Resource r) {
6120                 String name = null;
6121                 try {
6122                         name = getPossibleRelatedValue(r, processor.getL0(this).HasName);
6123                 } catch (ManyObjectsForFunctionalRelationException e) {
6124                 Logger.defaultLogError(e);
6125                 } catch (ServiceException e) {
6126                 Logger.defaultLogError(e);
6127                 }
6128                 return "[" + name + " - " + r + "]";
6129         }
6130
6131         @Override
6132         public String toString() {
6133                 return "ReadGraphImpl[thread=" + Thread.currentThread() + "]";
6134         }
6135
6136         @Override
6137         final public int thread() {
6138                 return 0;
6139         }
6140
6141     static class MultiTripleIntProcedure implements TripleIntProcedure {
6142
6143         final private AsyncMultiProcedure<Statement> procedure;
6144         final private ReadGraphImpl impl;
6145         final private QuerySupport support;
6146
6147         public MultiTripleIntProcedure(AsyncMultiProcedure<Statement> procedure, ReadGraphImpl impl, QuerySupport support) {
6148                 this.procedure = procedure;
6149                 this.impl = impl;
6150                 this.support = support;
6151         }
6152
6153         @Override
6154         public void execute(ReadGraphImpl graph, int s, int p, int o) {
6155                 try {
6156                         procedure.execute(graph, support.getStatement(s, p, o));
6157                 } catch (Throwable t2) {
6158                         Logger.defaultLogError(t2);
6159                 }
6160         }
6161
6162         @Override
6163         public void finished(ReadGraphImpl graph) {
6164                 try {
6165                         procedure.finished(graph);
6166 //                      impl.state.barrier.dec("ReadGraphSupportImpl.516");
6167                 } catch (Throwable t2) {
6168                         Logger.defaultLogError(t2);
6169                 }
6170         }
6171
6172         @Override
6173         public void exception(ReadGraphImpl graph, Throwable t) {
6174                 try {
6175                         procedure.exception(graph, t);
6176                 } catch (Throwable t2) {
6177                         Logger.defaultLogError(t2);
6178                 }
6179 //              impl.state.barrier.dec("ReadGraphSupportImpl.516");
6180         }
6181
6182         @Override
6183         public String toString() {
6184                 return "forEachObject with " + procedure;
6185         }
6186
6187     }
6188
6189 //    private AsyncMultiProcedure<Resource> cacheKey = null;
6190 //    private MultiIntProcedure cacheResult = null;
6191 //
6192 //    final IntProcedure forMultiProcedure(final AsyncMultiProcedure<Resource> procedure) {
6193 //
6194 //      if(procedure == cacheKey) return cacheResult;
6195 //
6196 //      cacheResult = new MultiIntProcedure(procedure, this, processor.support);
6197 //      cacheKey = procedure;
6198 //
6199 //      return cacheResult;
6200 //
6201 //    }
6202 //
6203 //    private AsyncMultiProcedure<Statement> cacheKey2 = null;
6204 //    private MultiTripleIntProcedure cacheResult2 = null;
6205 //
6206 //    final synchronized TripleIntProcedure forMultiProcedure(final AsyncMultiProcedure<Statement> procedure) {
6207 //
6208 //      if(procedure == cacheKey2) return cacheResult2;
6209 //
6210 //      cacheResult2 = new MultiTripleIntProcedure(procedure, this, processor.support);
6211 //      cacheKey2 = procedure;
6212 //
6213 //      return cacheResult2;
6214 //
6215 //    }
6216
6217     @Override
6218     public Datatype getDataType(Resource subject) throws DatabaseException {
6219         for(Resource dataTypeResource : getObjects(subject, processor.getL0(this).HasDataType))
6220                 return getValue(dataTypeResource, Bindings.getBindingUnchecked(Datatype.class));
6221         throw new DoesNotContainValueException("The literal has no data type.");
6222     }
6223
6224     protected <T extends Accessor> T getAccessor4File(Resource subject)
6225     throws DatabaseException {
6226         return null;
6227         /*
6228         byte[]  bytes = processor.support.getValue(g, subject);
6229         if (null == bytes)
6230             return null;
6231         try {
6232             BinaryVariant va = (BinaryVariant) Accessors.getAccessor(bytes, Datatypes.VARIANT);
6233             Accessor ca = va.getContentAccessor();
6234             return (T)ca;
6235         } catch (AccessorConstructionException e) {
6236             throw new DatabaseException(e);
6237         }
6238         */
6239         /*
6240         if (null == bytes)
6241             return null;
6242         Binding datatype_binding = Bindings.getBindingUnchecked(DataType.class);
6243         Serializer datatype_serializer = datatype_binding.serializer();
6244         DataType datatype;
6245         try {
6246             BinaryMemory in = new BinaryMemory(ByteBuffer.wrap(bytes));
6247             datatype = (DataType)datatype_serializer.deserialize(in);
6248             Binding data_binding = Bindings.getBinding(datatype);
6249             Serializer data_serializer = data_binding.serializer(BinarySerializationFormat.INSTANCE);
6250             Object o = data_serializer.deserialize(in);
6251             try {
6252                 return (T)Accessors.getAccessor(data_binding, o);
6253             } catch(AccessorConstructionException e) {
6254                 return null;
6255             }
6256         } catch (Exception e) {
6257             throw new DatabaseException(e);
6258         }*/
6259     }
6260     @SuppressWarnings("unchecked")
6261     @Override
6262     public <T extends Accessor> T getAccessor(Resource subject) throws DatabaseException {
6263         RandomAccessBinary rab = getRandomAccessBinary(subject);
6264         try {
6265             return (T)Accessors.getAccessor(rab, getDataType(subject));
6266         } catch(AccessorConstructionException e) {
6267             throw new DatabaseException(e);
6268         }
6269     }
6270     @SuppressWarnings("unchecked")
6271     protected <T extends Accessor> T createAccessor(Resource resource, Datatype datatype, Object intialValue)
6272     throws DatabaseException {
6273         RandomAccessBinary rab = createRandomAccessBinary(resource, datatype, intialValue);
6274         try {
6275             return (T)Accessors.getAccessor(rab, datatype);
6276         } catch(AccessorConstructionException e) {
6277             throw new DatabaseException(e);
6278         }
6279     }
6280     @Override
6281     public RandomAccessBinary getRandomAccessBinary(Resource subject) throws DatabaseException {
6282         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6283         ResourceData rd = ravs.get(subject);
6284         if (null != rd)
6285             return rd;
6286         try {
6287             ExternalValueSupport evs = getService(ExternalValueSupport.class);
6288             long size = evs.getValueSize(this, subject); // Throws DatabaseException if no old external value.
6289             try {
6290                 File platform = Platform.getLocation().toFile();
6291                 File tempFiles = new File(platform, "tempFiles");
6292                 File dbDir = new File(tempFiles, "db");
6293                 dbDir.mkdirs();
6294                 File file = new File(dbDir, "ResourceFile" + subject.getResourceId());
6295                 rd = new ResourceData(new BinaryFile(file), true); // Old external value.
6296                 final int N = 1<<20;
6297                 long left = size;
6298                 long offset = 0;
6299                 while (left > 0) {
6300                     int length = N < left ? N : (int)left;
6301                     byte[] bytes = evs.readValue(this, subject, offset, length);
6302                     offset += bytes.length;
6303                     left -= bytes.length;
6304                     rd.binaryFile.write(bytes);
6305                 }
6306                 ravs.put(subject, rd);
6307                 return rd;
6308             } catch (Exception e) {
6309                 throw new DatabaseException("Resource " + subject + " have value but there was problem with accessing value data.", e);
6310             }
6311         } catch (Exception e) {
6312             if(Development.DEVELOPMENT) {
6313                 if(Development.<Boolean>getProperty(DevelopmentKeys.WRITEGRAPH_EXCEPTION_STACKTRACES, Bindings.BOOLEAN)) {
6314                     e.printStackTrace();
6315                 }
6316             }
6317         }
6318         Datatype datatype = getDataType(subject);
6319         Object value = getPossibleValue(subject, Bindings.getBinding(datatype));
6320         return createRandomAccessBinary(subject, datatype, value);
6321     }
6322     public RandomAccessBinary createRandomAccessBinary(Resource resource, Datatype datatype, Object initialValue)
6323     throws DatabaseException {
6324         RandomAccessValueSupport ravs = getSession().getService(RandomAccessValueSupport.class);
6325         try {
6326             File platform = Platform.getLocation().toFile();
6327             File tempFiles = new File(platform, "tempFiles");
6328             File dbDir = new File(tempFiles, "db");
6329             dbDir.mkdirs();
6330             File file = new File(dbDir, "ResourceFile" + resource.getResourceId());
6331             ResourceData rd = new ResourceData(new BinaryFile(file), false);
6332             Binding binding = Bindings.getBinding(datatype);
6333             if (null == initialValue) {
6334                 initialValue = binding.createDefault();
6335             }
6336             Serializer serializer = binding.serializer();
6337             byte[] bytes = serializer.serialize(initialValue);
6338             rd.binaryFile.write(bytes);
6339             ravs.put(resource, rd);
6340             return rd;
6341         } catch (Exception e) {
6342             if (e instanceof DatabaseException)
6343                 throw (DatabaseException)e;
6344             else
6345                 throw new DatabaseException(e);
6346         }
6347     }
6348
6349 //    static class ExternalValueRequest<T> extends ResourceRead<T> {
6350 //
6351 //              public ExternalValueRequest(Resource resource) {
6352 //                      super(resource);
6353 //              }
6354 //
6355 //              @SuppressWarnings("unchecked")
6356 //              @Override
6357 //              public T perform(ReadGraph graph) throws DatabaseException {
6358 //              try {
6359 //
6360 //                      String uri = graph.getURI(resource);
6361 //                      if(Layer0.URIs.Functions_functionApplication.equals(uri)) return (T)functionApplication;
6362 //
6363 //                      return (T)ReflectionUtils.getValue(uri).getValue();
6364 //
6365 //              } catch(ValueNotFoundException e) {
6366 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6367 //              } catch(ClassCastException e) {
6368 //                      throw new DatabaseException("Couldn't convert to external value (r=" + resource + ")", e);
6369 //              }
6370 //              }
6371 //
6372 //    }
6373
6374     @SuppressWarnings("unchecked")
6375     @Override
6376     public <T> T getValue2(Resource r, Object context) throws DatabaseException {
6377         Layer0 L0 = processor.getL0(this);
6378         Set<Resource> types = getTypes(r);
6379
6380         if(types.contains(L0.Literal)) {
6381                 if(isImmutable(r)) {
6382                         return syncRequest(new ValueImplied<T>(r));
6383                 } else {
6384                         return getValue(r);
6385                 }
6386         }
6387         else if(types.contains(L0.ExternalValue)) {
6388                 return (T)syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6389         }
6390         else {
6391
6392             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6393             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6394             try {
6395                 return function.apply(this, r, context);
6396             } catch(RuntimeException e) {
6397                 DatabaseException dte = findPossibleRootException(e);
6398                 if(dte != null) throw dte;
6399                 else throw new DatabaseException(e);
6400             }
6401
6402         }
6403     }
6404
6405     @Override
6406     public Variant getVariantValue2(Resource r, Object context) throws DatabaseException {
6407         Layer0 L0 = processor.getL0(this);
6408         Set<Resource> types = getTypes(r);
6409
6410         if(types.contains(L0.Literal)) {
6411             if(isImmutable(r)) {
6412                 return syncRequest(new VariantValueImplied(r));
6413             } else {
6414                 return getVariantValue(r);
6415             }
6416         }
6417         else if(types.contains(L0.ExternalValue)) {
6418             Object value = syncRequest(new AdaptValue(r), TransientCacheListener.<Object>instance());
6419             try {
6420                 return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6421             } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6422                 throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6423             }
6424         }
6425         else {
6426
6427             Function3<ReadGraph,Resource,Object,Object> function = requestValueFunction(r);
6428             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function " + r);
6429             try {
6430                 Object value = function.apply(this, r, context);
6431                 try {
6432                     return new Variant(Bindings.OBJECT.getContentBinding(value), value);
6433                 } catch ( org.simantics.databoard.binding.error.BindingException e ) {
6434                     throw new BindingException( "No binding found for class " + value.getClass().getName(), e );
6435                 }
6436             } catch(RuntimeException e) {
6437                 DatabaseException dte = findPossibleRootException(e);
6438                 if(dte != null) throw dte;
6439                 else throw new DatabaseException(e);
6440             }
6441         }
6442     }
6443
6444     @Override
6445     public <T> T getPossibleValue2(Resource subject, Object context) throws DatabaseException {
6446         try {
6447                 return getValue2(subject, context);
6448         } catch (DatabaseException e) {
6449                 return null;
6450         }
6451     }
6452
6453     static class PossibleConverterFunction<T> extends ResourceRead<Function3<ReadGraph,Resource,Object,T>> {
6454
6455         public PossibleConverterFunction(Resource resource) {
6456                         super(resource);
6457                 }
6458
6459         @Override
6460         public Function3<ReadGraph,Resource,Object,T> perform(ReadGraph graph) throws DatabaseException {
6461                 return compute(graph, resource);
6462         }
6463
6464         @SuppressWarnings("unchecked")
6465                 public static <T> Function3<ReadGraph,Resource,Object,T> compute(ReadGraph graph, Resource resource) throws DatabaseException {
6466             Layer0 L0 = Layer0.getInstance(graph);
6467             for(Resource converter : graph.getObjects(resource, L0.ConvertsToValueWith)) {
6468                 try {
6469                         if(L0.Functions_functionApplication.equals(converter)) {
6470                                 return (Function3<ReadGraph,Resource,Object,T>)graph.syncRequest(new AdaptValue(resource));
6471                         } else {
6472                                 return graph.getValue2(converter, resource);
6473                         }
6474                 } catch(RuntimeException e) {
6475                     DatabaseException dte = findPossibleRootException(e);
6476                     if(dte != null) throw dte;
6477                     else throw new DatabaseException(e);
6478                 }
6479             }
6480             return null;
6481         }
6482
6483     }
6484
6485     <T> Function3<ReadGraph,Resource,Object,T> requestValueFunction(Resource r) throws DatabaseException {
6486         if(isImmutable(r))
6487                 return syncRequest(new PossibleConverterFunction<T>(r), TransientCacheAsyncListener.<Function3<ReadGraph,Resource,Object,T>>instance());
6488         else
6489                 return syncRequest(new PossibleConverterFunction<T>(r));
6490     }
6491
6492     /**
6493      * Get a value associated with a graph {@link Resource}, using a possible context object and
6494      * a desired value binding. The following methods are tried in order to retreive the value:
6495      * <ol>
6496      *   <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>
6497      *   <li>If the resource is a {@code L0.ExternalValue}, the value is acquired using
6498      *       {@link ReflectionUtils#getValue(String)}.</li>
6499      *   <li>If the resource is associated with a suitable value converter with relation {@code L0.ConvertsToValueWith}
6500      *       (see {@link #requestValueFunction(Resource)}), the value function is called with the graph, the resource
6501      *       and the context object.</li>
6502      * </ul>
6503      *
6504      * @param r  A graph resource with which the value is associated
6505      * @param context  A context object that is used for acquiring the value (only applied in case 3)
6506      * @param binding  A binding for the value type (only applied in case 1)
6507      * @return  The value of the graph node.
6508      * @throws DoesNotContainValueException  No value is associated with the graph node.
6509      * @throws DatabaseException  Other errors, such as an error in casting the value to the return type or
6510      *         a runtime error in the value function.
6511      */
6512     @SuppressWarnings("unchecked")
6513         @Override
6514     public <T> T getValue2(Resource r, Object context, Binding binding) throws DatabaseException {
6515         if (binding instanceof ObjectVariantBinding)
6516                 return getValue2(r, context);
6517
6518         Layer0 L0 = processor.getL0(this);
6519         Set<Resource> types = getTypes(r);
6520         if(types.contains(L0.Literal)) {
6521                 if(isImmutable(r)) {
6522                         return syncRequest(new Value<T>(r, binding));
6523                 } else {
6524                         return getValue(r, binding);
6525                 }
6526         } else if(types.contains(L0.ExternalValue)) {
6527                 try {
6528                         return (T)ReflectionUtils.getValue(getURI(r)).getValue();
6529                 } catch(ValueNotFoundException e) {
6530                         throw new DatabaseException(e);
6531                 } catch(ClassCastException e) {
6532                         throw new DatabaseException(e);
6533                 }
6534         }
6535         else {
6536             Function3<ReadGraph,Resource,Object,T> function = requestValueFunction(r);
6537             if(function == null) throw new DoesNotContainValueException("Couldn't convert to a value function.");
6538             try {
6539                 Object value = function.apply(this, r, context);
6540                 if(binding.isInstance(value)) return (T)value;
6541                 Binding srcBinding = Bindings.OBJECT.getContentBinding(value);
6542                 return (T)Bindings.adapt(value, srcBinding, binding);
6543             } catch(RuntimeException e) {
6544                 DatabaseException dte = findPossibleRootException(e);
6545                 if(dte != null) throw dte;
6546                 else throw new DatabaseException(e);
6547             } catch (AdaptException e) {
6548                 throw new DatabaseException(e);
6549                         } catch (org.simantics.databoard.binding.error.BindingException e) {
6550                 throw new DatabaseException(e);
6551                         }
6552         }
6553     }
6554
6555     @Override
6556     public <T> T getPossibleValue2(Resource subject, Object context, Binding binding) throws DatabaseException {
6557         try {
6558                 return getValue2(subject, context, binding);
6559         } catch (DatabaseException e) {
6560                 return null;
6561         }
6562     }
6563
6564         private static DatabaseException findPossibleRootException(Throwable t) {
6565                 if(t == null) return null;
6566                 if(t instanceof DatabaseException) return (DatabaseException)t;
6567                 if(t instanceof RuntimeException || t instanceof InvocationTargetException) {
6568                         return findPossibleRootException(t.getCause());
6569                 }
6570                 return null;
6571         }
6572
6573     @Override
6574     public <T> T getRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6575         return getRelatedValue2(subject, relation, subject);
6576     }
6577
6578     @Override
6579     public Variant getRelatedVariantValue2(Resource subject, Resource relation) throws DatabaseException {
6580         return getRelatedVariantValue2(subject, relation, subject);
6581     }
6582
6583     @Override
6584     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation) throws DatabaseException {
6585         try {
6586                 Resource object = getPossibleObject(subject, relation);
6587                 if(object == null) return null;
6588                 else return getValue2(object, subject);
6589         } catch (DatabaseException e) {
6590                 return null;
6591         }
6592     }
6593
6594     @Override
6595     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6596                 if(Development.DEVELOPMENT) {
6597                         String error = L0Validations.checkValueType(this, subject, relation);
6598                         if(error != null) {
6599                                 Logger.defaultLogError(new ValidationException(error));
6600                                 //throw new ValidationException(error);
6601                                 new ValidationException(error).printStackTrace();
6602                         }
6603                 }
6604         return getValue2(getSingleObject(subject, relation), context);
6605     }
6606
6607     @Override
6608     public Variant getRelatedVariantValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6609         if(Development.DEVELOPMENT) {
6610             String error = L0Validations.checkValueType(this, subject, relation);
6611             if(error != null) {
6612                 Logger.defaultLogError(new ValidationException(error));
6613                 //throw new ValidationException(error);
6614                 new ValidationException(error).printStackTrace();
6615             }
6616         }
6617         return getVariantValue2(getSingleObject(subject, relation), context);
6618     }
6619
6620     @Override
6621     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context) throws DatabaseException {
6622         try {
6623                 Resource object = getPossibleObject(subject, relation);
6624                 if(object == null) return null;
6625                 else return getValue2(object, context);
6626         } catch (DatabaseException e) {
6627                 return null;
6628         }
6629     }
6630
6631     @Override
6632     public <T> T getRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6633         return getRelatedValue2(subject, relation, subject, binding);
6634     }
6635
6636     @Override
6637     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Binding binding) throws DatabaseException {
6638         try {
6639                 Resource object = getPossibleObject(subject, relation);
6640                 if(object == null) return null;
6641                 return getValue2(object, subject, binding);
6642         } catch (DatabaseException e) {
6643                 return null;
6644         }
6645     }
6646
6647     @Override
6648     public <T> T getRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6649         return getValue2(getSingleObject(subject, relation), context, binding);
6650     }
6651
6652     @Override
6653     public <T> T getPossibleRelatedValue2(Resource subject, Resource relation, Object context, Binding binding) throws DatabaseException {
6654         try {
6655                 Resource object = getPossibleObject(subject, relation);
6656                 if(object == null) return null;
6657                 else return getValue2(object, context, binding);
6658         } catch (DatabaseException e) {
6659                 return null;
6660         }
6661     }
6662
6663     @Override
6664     public Type getRelatedValueType(Resource subject, Resource relation) throws DatabaseException {
6665         Layer0 L0 = processor.getL0(this);
6666         Resource property = getSingleObject(subject, relation);
6667         String typeText = (String)getRelatedValue(property, L0.HasValueType, Bindings.STRING);
6668         try {
6669             return org.simantics.scl.compiler.types.Types.parseType(typeText);
6670         } catch (SCLTypeParseException e) {
6671             throw new DatabaseException(e);
6672         }
6673     }
6674
6675     @Override
6676     public boolean setSynchronous(boolean value) {
6677         boolean old = processor.synch;
6678         processor.synch = value;
6679         return old;
6680     }
6681
6682     @Override
6683     public boolean getSynchronous() {
6684         return processor.synch;
6685     }
6686
6687     public void ensureLoaded(int resource) {
6688         processor.querySupport.ensureLoaded(this, resource);
6689     }
6690
6691     public void ensureLoaded(int resource, int predicate) {
6692         processor.querySupport.ensureLoaded(this, resource, predicate);
6693     }
6694
6695     public byte[] getValue(int resource) {
6696         return processor.querySupport.getValue(this, resource);
6697     }
6698
6699     public int thread(int resource) {
6700         return (resource >>> 16) & processor.THREAD_MASK;
6701     }
6702
6703     public int thread(Resource resource) {
6704         return (((ResourceImpl)resource).id >>> 16) & processor.THREAD_MASK;
6705     }
6706
6707     public ResourceSupport getResourceSupport() {
6708         return processor.getResourceSupport();
6709     }
6710
6711     @Override
6712     public Object getModificationCounter() {
6713         return processor.getSession().getModificationCounter();
6714     }
6715
6716 }