bundles/org.simantics.db.impl/src/org/simantics/db/impl/graph/ReadGraphImpl.java

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