org.simantics.interop.mapping/src/org/simantics/interop/mapping/SplittingWriteGraph.java

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