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